core::alloc::layout::Layout::from_size_align_unchecked::precondition_check const fn precondition_check($($name:$ty),*) {
if !$e {
// Ferrocene annotation: This code cannot be covered because it causes an
// non-unwinding panic, which means it cannot be caught by any means in a test.
let msg = concat!("unsafe precondition(s) violated: ", $message,
"\n\nThis indicates a bug in the program. \
This Undefined Behavior check is optional, and cannot be relied on for safety.");
// blocked on fmt::Arguments
#[cfg(not(feature = "ferrocene_certified"))]
::core::panicking::panic_nounwind_fmt(::core::fmt::Arguments::new_const(&[msg]), false);
#[cfg(feature = "ferrocene_certified")]
::core::panicking::panic_nounwind(msg);
}
}
core::cmp::default_chaining_implconst fn default_chaining_impl<T, U>(
lhs: &T,
rhs: &U,
p: impl [const] FnOnce(Ordering) -> bool + [const] Destruct,
) -> ControlFlow<bool>
where
T: [const] PartialOrd<U> + PointeeSized,
U: PointeeSized,
{
// It's important that this only call `partial_cmp` once, not call `eq` then
// one of the relational operators. We don't want to `bcmp`-then-`memcp` a
// `String`, for example, or similarly for other data structures (#108157).
match <T as PartialOrd<U>>::partial_cmp(lhs, rhs) {
Some(Equal) => ControlFlow::Continue(()),
Some(c) => ControlFlow::Break(p(c)),
None => ControlFlow::Break(false),
}
}
core::cmp::impls::<impl core::cmp::Ord for bool>::cmp fn cmp(&self, other: &bool) -> Ordering {
// Casting to i8's and converting the difference to an Ordering generates
// more optimal assembly.
// See <https://github.com/rust-lang/rust/issues/66780> for more info.
match (*self as i8) - (*other as i8) {
-1 => Less,
0 => Equal,
1 => Greater,
// Ferrocene annotation: This match arm cannot be covered because it is unreachable.
// See the safety comment below.
//
// SAFETY: bool as i8 returns 0 or 1, so the difference can't be anything else
_ => unsafe { unreachable_unchecked() },
}
}
core::hint::unreachable_unchecked::precondition_check const fn precondition_check($($name:$ty),*) {
if !$e {
// Ferrocene annotation: This code cannot be covered because it causes an
// non-unwinding panic, which means it cannot be caught by any means in a test.
let msg = concat!("unsafe precondition(s) violated: ", $message,
"\n\nThis indicates a bug in the program. \
This Undefined Behavior check is optional, and cannot be relied on for safety.");
// blocked on fmt::Arguments
#[cfg(not(feature = "ferrocene_certified"))]
::core::panicking::panic_nounwind_fmt(::core::fmt::Arguments::new_const(&[msg]), false);
#[cfg(feature = "ferrocene_certified")]
::core::panicking::panic_nounwind(msg);
}
}
core::ptr::alignment::Alignment::new_unchecked::precondition_check const fn precondition_check($($name:$ty),*) {
if !$e {
// Ferrocene annotation: This code cannot be covered because it causes an
// non-unwinding panic, which means it cannot be caught by any means in a test.
let msg = concat!("unsafe precondition(s) violated: ", $message,
"\n\nThis indicates a bug in the program. \
This Undefined Behavior check is optional, and cannot be relied on for safety.");
// blocked on fmt::Arguments
#[cfg(not(feature = "ferrocene_certified"))]
::core::panicking::panic_nounwind_fmt(::core::fmt::Arguments::new_const(&[msg]), false);
#[cfg(feature = "ferrocene_certified")]
::core::panicking::panic_nounwind(msg);
}
}
core::ptr::const_ptr::<impl *const T>::guaranteed_eq pub const fn guaranteed_eq(self, other: *const T) -> Option<bool>
where
T: Sized,
{
match intrinsics::ptr_guaranteed_cmp(self, other) {
// Ferrocene annotation: This cannot be reached in runtime code so it cannot be covered.
2 => None,
other => Some(other == 1),
}
}
core::ptr::read::precondition_check const fn precondition_check($($name:$ty),*) {
if !$e {
// Ferrocene annotation: This code cannot be covered because it causes an
// non-unwinding panic, which means it cannot be caught by any means in a test.
let msg = concat!("unsafe precondition(s) violated: ", $message,
"\n\nThis indicates a bug in the program. \
This Undefined Behavior check is optional, and cannot be relied on for safety.");
// blocked on fmt::Arguments
#[cfg(not(feature = "ferrocene_certified"))]
::core::panicking::panic_nounwind_fmt(::core::fmt::Arguments::new_const(&[msg]), false);
#[cfg(feature = "ferrocene_certified")]
::core::panicking::panic_nounwind(msg);
}
}
core::ptr::write::precondition_check const fn precondition_check($($name:$ty),*) {
if !$e {
// Ferrocene annotation: This code cannot be covered because it causes an
// non-unwinding panic, which means it cannot be caught by any means in a test.
let msg = concat!("unsafe precondition(s) violated: ", $message,
"\n\nThis indicates a bug in the program. \
This Undefined Behavior check is optional, and cannot be relied on for safety.");
// blocked on fmt::Arguments
#[cfg(not(feature = "ferrocene_certified"))]
::core::panicking::panic_nounwind_fmt(::core::fmt::Arguments::new_const(&[msg]), false);
#[cfg(feature = "ferrocene_certified")]
::core::panicking::panic_nounwind(msg);
}
}
core::ops::drop::Drop::drop fn drop(&mut self);
core::panic::panic_info::PanicInfo::<'a>::new pub(crate) fn new(message: &'a PanicFmt<'a>) -> Self {
PanicInfo { message }
}
<&T as core::convert::AsRef<U>>::as_ref fn as_ref(&self) -> &U {
<T as AsRef<U>>::as_ref(*self)
}
<&T as core::ops::deref::Deref>::deref fn deref(&self) -> &T {
self
}
<&bool as core::ops::bit::BitAnd<&bool>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&bool as core::ops::bit::BitAnd<bool>>::bitand fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&bool as core::ops::bit::BitOr<&bool>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&bool as core::ops::bit::BitOr<bool>>::bitor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&bool as core::ops::bit::BitXor<&bool>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&bool as core::ops::bit::BitXor<bool>>::bitxor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&bool as core::ops::bit::Not>::not fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&f32 as core::ops::arith::Add<&f32>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&f32 as core::ops::arith::Add<f32>>::add fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&f32 as core::ops::arith::Div<&f32>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&f32 as core::ops::arith::Div<f32>>::div fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&f32 as core::ops::arith::Mul<&f32>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&f32 as core::ops::arith::Mul<f32>>::mul fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&f32 as core::ops::arith::Neg>::neg fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&f32 as core::ops::arith::Rem<&f32>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&f32 as core::ops::arith::Rem<f32>>::rem fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&f32 as core::ops::arith::Sub<&f32>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&f32 as core::ops::arith::Sub<f32>>::sub fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&f64 as core::ops::arith::Add<&f64>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&f64 as core::ops::arith::Add<f64>>::add fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&f64 as core::ops::arith::Div<&f64>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&f64 as core::ops::arith::Div<f64>>::div fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&f64 as core::ops::arith::Mul<&f64>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&f64 as core::ops::arith::Mul<f64>>::mul fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&f64 as core::ops::arith::Neg>::neg fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&f64 as core::ops::arith::Rem<&f64>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&f64 as core::ops::arith::Rem<f64>>::rem fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&f64 as core::ops::arith::Sub<&f64>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&f64 as core::ops::arith::Sub<f64>>::sub fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::arith::Add<&i128>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::arith::Add<i128>>::add fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::arith::Div<&i128>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::arith::Div<i128>>::div fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::arith::Mul<&i128>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::arith::Mul<i128>>::mul fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::arith::Neg>::neg fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&i128 as core::ops::arith::Rem<&i128>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::arith::Rem<i128>>::rem fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::arith::Sub<&i128>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::arith::Sub<i128>>::sub fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::BitAnd<&i128>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::BitAnd<i128>>::bitand fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::BitOr<&i128>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::BitOr<i128>>::bitor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::BitXor<&i128>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::BitXor<i128>>::bitxor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Not>::not fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&i128 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shl<i128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shl<i16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shl<i32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shl<i64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shl<i8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shl<isize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shl<u128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shl<u16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shl<u32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shl<u64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shl<u8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shl<usize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i128 as core::ops::bit::Shr<i128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shr<i16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shr<i32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shr<i64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shr<i8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shr<isize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shr<u128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shr<u16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shr<u32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shr<u64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shr<u8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i128 as core::ops::bit::Shr<usize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::arith::Add<&i16>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::arith::Add<i16>>::add fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::arith::Div<&i16>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::arith::Div<i16>>::div fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::arith::Mul<&i16>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::arith::Mul<i16>>::mul fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::arith::Neg>::neg fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&i16 as core::ops::arith::Rem<&i16>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::arith::Rem<i16>>::rem fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::arith::Sub<&i16>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::arith::Sub<i16>>::sub fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::BitAnd<&i16>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::BitAnd<i16>>::bitand fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::BitOr<&i16>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::BitOr<i16>>::bitor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::BitXor<&i16>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::BitXor<i16>>::bitxor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Not>::not fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&i16 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shl<i128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shl<i16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shl<i32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shl<i64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shl<i8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shl<isize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shl<u128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shl<u16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shl<u32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shl<u64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shl<u8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shl<usize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i16 as core::ops::bit::Shr<i128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shr<i16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shr<i32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shr<i64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shr<i8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shr<isize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shr<u128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shr<u16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shr<u32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shr<u64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shr<u8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i16 as core::ops::bit::Shr<usize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::arith::Add<&i32>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::arith::Add<i32>>::add fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::arith::Div<&i32>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::arith::Div<i32>>::div fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::arith::Mul<&i32>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::arith::Mul<i32>>::mul fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::arith::Neg>::neg fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&i32 as core::ops::arith::Rem<&i32>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::arith::Rem<i32>>::rem fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::arith::Sub<&i32>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::arith::Sub<i32>>::sub fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::BitAnd<&i32>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::BitAnd<i32>>::bitand fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::BitOr<&i32>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::BitOr<i32>>::bitor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::BitXor<&i32>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::BitXor<i32>>::bitxor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Not>::not fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&i32 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shl<i128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shl<i16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shl<i32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shl<i64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shl<i8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shl<isize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shl<u128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shl<u16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shl<u32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shl<u64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shl<u8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shl<usize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i32 as core::ops::bit::Shr<i128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shr<i16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shr<i32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shr<i64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shr<i8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shr<isize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shr<u128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shr<u16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shr<u32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shr<u64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shr<u8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i32 as core::ops::bit::Shr<usize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::arith::Add<&i64>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::arith::Add<i64>>::add fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::arith::Div<&i64>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::arith::Div<i64>>::div fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::arith::Mul<&i64>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::arith::Mul<i64>>::mul fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::arith::Neg>::neg fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&i64 as core::ops::arith::Rem<&i64>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::arith::Rem<i64>>::rem fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::arith::Sub<&i64>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::arith::Sub<i64>>::sub fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::BitAnd<&i64>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::BitAnd<i64>>::bitand fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::BitOr<&i64>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::BitOr<i64>>::bitor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::BitXor<&i64>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::BitXor<i64>>::bitxor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Not>::not fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&i64 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shl<i128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shl<i16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shl<i32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shl<i64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shl<i8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shl<isize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shl<u128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shl<u16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shl<u32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shl<u64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shl<u8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shl<usize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i64 as core::ops::bit::Shr<i128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shr<i16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shr<i32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shr<i64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shr<i8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shr<isize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shr<u128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shr<u16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shr<u32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shr<u64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shr<u8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i64 as core::ops::bit::Shr<usize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::arith::Add<&i8>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::arith::Add<i8>>::add fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::arith::Div<&i8>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::arith::Div<i8>>::div fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::arith::Mul<&i8>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::arith::Mul<i8>>::mul fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::arith::Neg>::neg fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&i8 as core::ops::arith::Rem<&i8>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::arith::Rem<i8>>::rem fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::arith::Sub<&i8>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::arith::Sub<i8>>::sub fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::BitAnd<&i8>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::BitAnd<i8>>::bitand fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::BitOr<&i8>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::BitOr<i8>>::bitor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::BitXor<&i8>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::BitXor<i8>>::bitxor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Not>::not fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&i8 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shl<i128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shl<i16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shl<i32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shl<i64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shl<i8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shl<isize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shl<u128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shl<u16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shl<u32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shl<u64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shl<u8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shl<usize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&i8 as core::ops::bit::Shr<i128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shr<i16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shr<i32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shr<i64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shr<i8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shr<isize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shr<u128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shr<u16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shr<u32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shr<u64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shr<u8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&i8 as core::ops::bit::Shr<usize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::arith::Add<&isize>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::arith::Add<isize>>::add fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::arith::Div<&isize>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::arith::Div<isize>>::div fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::arith::Mul<&isize>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::arith::Mul<isize>>::mul fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::arith::Neg>::neg fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&isize as core::ops::arith::Rem<&isize>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::arith::Rem<isize>>::rem fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::arith::Sub<&isize>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::arith::Sub<isize>>::sub fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::BitAnd<&isize>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::BitAnd<isize>>::bitand fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::BitOr<&isize>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::BitOr<isize>>::bitor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::BitXor<&isize>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::BitXor<isize>>::bitxor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Not>::not fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&isize as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shl<i128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shl<i16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shl<i32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shl<i64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shl<i8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shl<isize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shl<u128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shl<u16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shl<u32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shl<u64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shl<u8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shl<usize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&isize as core::ops::bit::Shr<i128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shr<i16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shr<i32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shr<i64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shr<i8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shr<isize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shr<u128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shr<u16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shr<u32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shr<u64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shr<u8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&isize as core::ops::bit::Shr<usize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&mut T as core::convert::AsMut<U>>::as_mut fn as_mut(&mut self) -> &mut U {
(*self).as_mut()
}
<&mut T as core::convert::AsRef<U>>::as_ref fn as_ref(&self) -> &U {
<T as AsRef<U>>::as_ref(*self)
}
<&mut T as core::ops::deref::Deref>::deref fn deref(&self) -> &T {
self
}
<&mut T as core::ops::deref::DerefMut>::deref_mut fn deref_mut(&mut self) -> &mut T {
self
}
<&u128 as core::ops::arith::Add<&u128>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::arith::Add<u128>>::add fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::arith::Div<&u128>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::arith::Div<u128>>::div fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::arith::Mul<&u128>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::arith::Mul<u128>>::mul fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::arith::Rem<&u128>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::arith::Rem<u128>>::rem fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::arith::Sub<&u128>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::arith::Sub<u128>>::sub fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::BitAnd<&u128>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::BitAnd<u128>>::bitand fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::BitOr<&u128>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::BitOr<u128>>::bitor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::BitXor<&u128>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::BitXor<u128>>::bitxor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Not>::not fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&u128 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shl<i128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shl<i16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shl<i32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shl<i64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shl<i8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shl<isize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shl<u128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shl<u16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shl<u32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shl<u64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shl<u8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shl<usize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u128 as core::ops::bit::Shr<i128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shr<i16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shr<i32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shr<i64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shr<i8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shr<isize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shr<u128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shr<u16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shr<u32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shr<u64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shr<u8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u128 as core::ops::bit::Shr<usize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::arith::Add<&u16>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::arith::Add<u16>>::add fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::arith::Div<&u16>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::arith::Div<u16>>::div fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::arith::Mul<&u16>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::arith::Mul<u16>>::mul fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::arith::Rem<&u16>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::arith::Rem<u16>>::rem fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::arith::Sub<&u16>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::arith::Sub<u16>>::sub fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::BitAnd<&u16>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::BitAnd<u16>>::bitand fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::BitOr<&u16>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::BitOr<u16>>::bitor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::BitXor<&u16>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::BitXor<u16>>::bitxor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Not>::not fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&u16 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shl<i128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shl<i16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shl<i32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shl<i64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shl<i8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shl<isize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shl<u128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shl<u16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shl<u32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shl<u64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shl<u8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shl<usize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u16 as core::ops::bit::Shr<i128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shr<i16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shr<i32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shr<i64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shr<i8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shr<isize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shr<u128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shr<u16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shr<u32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shr<u64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shr<u8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u16 as core::ops::bit::Shr<usize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::arith::Add<&u32>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::arith::Add<u32>>::add fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::arith::Div<&u32>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::arith::Div<u32>>::div fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::arith::Mul<&u32>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::arith::Mul<u32>>::mul fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::arith::Rem<&u32>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::arith::Rem<u32>>::rem fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::arith::Sub<&u32>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::arith::Sub<u32>>::sub fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::BitAnd<&u32>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::BitAnd<u32>>::bitand fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::BitOr<&u32>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::BitOr<u32>>::bitor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::BitXor<&u32>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::BitXor<u32>>::bitxor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Not>::not fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&u32 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shl<i128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shl<i16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shl<i32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shl<i64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shl<i8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shl<isize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shl<u128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shl<u16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shl<u32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shl<u64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shl<u8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shl<usize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u32 as core::ops::bit::Shr<i128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shr<i16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shr<i32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shr<i64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shr<i8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shr<isize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shr<u128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shr<u16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shr<u32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shr<u64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shr<u8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u32 as core::ops::bit::Shr<usize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::arith::Add<&u64>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::arith::Add<u64>>::add fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::arith::Div<&u64>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::arith::Div<u64>>::div fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::arith::Mul<&u64>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::arith::Mul<u64>>::mul fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::arith::Rem<&u64>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::arith::Rem<u64>>::rem fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::arith::Sub<&u64>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::arith::Sub<u64>>::sub fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::BitAnd<&u64>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::BitAnd<u64>>::bitand fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::BitOr<&u64>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::BitOr<u64>>::bitor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::BitXor<&u64>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::BitXor<u64>>::bitxor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Not>::not fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&u64 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shl<i128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shl<i16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shl<i32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shl<i64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shl<i8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shl<isize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shl<u128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shl<u16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shl<u32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shl<u64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shl<u8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shl<usize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u64 as core::ops::bit::Shr<i128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shr<i16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shr<i32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shr<i64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shr<i8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shr<isize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shr<u128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shr<u16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shr<u32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shr<u64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shr<u8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u64 as core::ops::bit::Shr<usize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::arith::Add<&u8>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::arith::Add<u8>>::add fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::arith::Div<&u8>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::arith::Div<u8>>::div fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::arith::Mul<&u8>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::arith::Mul<u8>>::mul fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::arith::Rem<&u8>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::arith::Rem<u8>>::rem fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::arith::Sub<&u8>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::arith::Sub<u8>>::sub fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::BitAnd<&u8>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::BitAnd<u8>>::bitand fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::BitOr<&u8>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::BitOr<u8>>::bitor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::BitXor<&u8>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::BitXor<u8>>::bitxor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Not>::not fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&u8 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shl<i128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shl<i16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shl<i32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shl<i64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shl<i8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shl<isize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shl<u128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shl<u16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shl<u32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shl<u64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shl<u8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shl<usize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&u8 as core::ops::bit::Shr<i128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shr<i16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shr<i32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shr<i64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shr<i8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shr<isize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shr<u128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shr<u16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shr<u32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shr<u64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shr<u8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&u8 as core::ops::bit::Shr<usize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::arith::Add<&usize>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::arith::Add<usize>>::add fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::arith::Div<&usize>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::arith::Div<usize>>::div fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::arith::Mul<&usize>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::arith::Mul<usize>>::mul fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::arith::Rem<&usize>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::arith::Rem<usize>>::rem fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::arith::Sub<&usize>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::arith::Sub<usize>>::sub fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::BitAnd<&usize>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::BitAnd<usize>>::bitand fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::BitOr<&usize>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::BitOr<usize>>::bitor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::BitXor<&usize>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::BitXor<usize>>::bitxor fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Not>::not fn $method(self) -> <$t as $imp>::Output {
$imp::$method(*self)
}
<&usize as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shl<i128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shl<i16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shl<i32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shl<i64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shl<i8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shl<isize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shl<u128>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shl<u16>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shl<u32>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shl<u64>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shl<u8>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shl<usize>>::shl fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, *other)
}
<&usize as core::ops::bit::Shr<i128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shr<i16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shr<i32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shr<i64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shr<i8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shr<isize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shr<u128>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shr<u16>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shr<u32>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shr<u64>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shr<u8>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<&usize as core::ops::bit::Shr<usize>>::shr fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
$imp::$method(*self, other)
}
<(core::ops::range::Bound<T>, core::ops::range::Bound<T>) as core::ops::range::IntoBounds<T>>::into_bounds fn into_bounds(self) -> (Bound<T>, Bound<T>) {
self
}
<(core::ops::range::Bound<T>, core::ops::range::Bound<T>) as core::ops::range::RangeBounds<T>>::end_bound fn end_bound(&self) -> Bound<&T> {
match *self {
(_, Included(ref end)) => Included(end),
(_, Excluded(ref end)) => Excluded(end),
(_, Unbounded) => Unbounded,
}
}
<(core::ops::range::Bound<T>, core::ops::range::Bound<T>) as core::ops::range::RangeBounds<T>>::start_bound fn start_bound(&self) -> Bound<&T> {
match *self {
(Included(ref start), _) => Included(start),
(Excluded(ref start), _) => Excluded(start),
(Unbounded, _) => Unbounded,
}
}
<T as core::convert::From<T>>::from fn from(t: T) -> T {
t
}
<T as core::convert::Into<U>>::into fn into(self) -> U {
U::from(self)
}
<T as core::convert::TryFrom<U>>::try_from fn try_from(value: U) -> Result<Self, Self::Error> {
Ok(U::into(value))
}
<T as core::convert::TryInto<U>>::try_into fn try_into(self) -> Result<U, U::Error> {
U::try_from(self)
}
<[T] as core::convert::AsMut<[T]>>::as_mut fn as_mut(&mut self) -> &mut [T] {
self
}
<bool as core::ops::bit::BitAnd<&bool>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<bool as core::ops::bit::BitAnd>::bitand fn bitand(self, rhs: $t) -> $t { self & rhs }
<bool as core::ops::bit::BitAndAssign<&bool>>::bitand_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<bool as core::ops::bit::BitAndAssign>::bitand_assign fn bitand_assign(&mut self, other: $t) { *self &= other }
<bool as core::ops::bit::BitOr<&bool>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<bool as core::ops::bit::BitOr>::bitor fn bitor(self, rhs: $t) -> $t { self | rhs }
<bool as core::ops::bit::BitOrAssign<&bool>>::bitor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<bool as core::ops::bit::BitOrAssign>::bitor_assign fn bitor_assign(&mut self, other: $t) { *self |= other }
<bool as core::ops::bit::BitXor<&bool>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<bool as core::ops::bit::BitXor>::bitxor fn bitxor(self, other: $t) -> $t { self ^ other }
<bool as core::ops::bit::BitXorAssign<&bool>>::bitxor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<bool as core::ops::bit::BitXorAssign>::bitxor_assign fn bitxor_assign(&mut self, other: $t) { *self ^= other }
<bool as core::ops::bit::Not>::not fn not(self) -> $t { !self }
<core::ops::control_flow::ControlFlow<B, C> as core::ops::try_trait::FromResidual<core::ops::control_flow::ControlFlow<B, core::convert::Infallible>>>::from_residual fn from_residual(residual: ControlFlow<B, convert::Infallible>) -> Self {
match residual {
ControlFlow::Break(b) => ControlFlow::Break(b),
}
}
<core::ops::control_flow::ControlFlow<B, C> as core::ops::try_trait::Try>::branch fn branch(self) -> ControlFlow<Self::Residual, Self::Output> {
match self {
ControlFlow::Continue(c) => ControlFlow::Continue(c),
ControlFlow::Break(b) => ControlFlow::Break(ControlFlow::Break(b)),
}
}
<core::ops::control_flow::ControlFlow<B, C> as core::ops::try_trait::Try>::from_output fn from_output(output: Self::Output) -> Self {
ControlFlow::Continue(output)
}
<core::ops::range::Range<&T> as core::ops::range::RangeBounds<T>>::end_bound fn end_bound(&self) -> Bound<&T> {
Excluded(self.end)
}
<core::ops::range::Range<&T> as core::ops::range::RangeBounds<T>>::start_bound fn start_bound(&self) -> Bound<&T> {
Included(self.start)
}
<core::ops::range::Range<T> as core::ops::range::IntoBounds<T>>::into_bounds fn into_bounds(self) -> (Bound<T>, Bound<T>) {
(Included(self.start), Excluded(self.end))
}
<core::ops::range::Range<T> as core::ops::range::RangeBounds<T>>::end_bound fn end_bound(&self) -> Bound<&T> {
Excluded(&self.end)
}
<core::ops::range::Range<T> as core::ops::range::RangeBounds<T>>::start_bound fn start_bound(&self) -> Bound<&T> {
Included(&self.start)
}
<core::ops::range::RangeFrom<&T> as core::ops::range::RangeBounds<T>>::end_bound fn end_bound(&self) -> Bound<&T> {
Unbounded
}
<core::ops::range::RangeFrom<&T> as core::ops::range::RangeBounds<T>>::start_bound fn start_bound(&self) -> Bound<&T> {
Included(self.start)
}
<core::ops::range::RangeFrom<T> as core::ops::range::IntoBounds<T>>::into_bounds fn into_bounds(self) -> (Bound<T>, Bound<T>) {
(Included(self.start), Unbounded)
}
<core::ops::range::RangeFrom<T> as core::ops::range::OneSidedRange<T>>::bound fn bound(self) -> (OneSidedRangeBound, T) {
(OneSidedRangeBound::StartInclusive, self.start)
}
<core::ops::range::RangeFrom<T> as core::ops::range::RangeBounds<T>>::end_bound fn end_bound(&self) -> Bound<&T> {
Unbounded
}
<core::ops::range::RangeFrom<T> as core::ops::range::RangeBounds<T>>::start_bound fn start_bound(&self) -> Bound<&T> {
Included(&self.start)
}
<core::ops::range::RangeFull as core::ops::range::IntoBounds<T>>::into_bounds fn into_bounds(self) -> (Bound<T>, Bound<T>) {
(Unbounded, Unbounded)
}
<core::ops::range::RangeFull as core::ops::range::RangeBounds<T>>::end_bound fn end_bound(&self) -> Bound<&T> {
Unbounded
}
<core::ops::range::RangeFull as core::ops::range::RangeBounds<T>>::start_bound fn start_bound(&self) -> Bound<&T> {
Unbounded
}
<core::ops::range::RangeInclusive<&T> as core::ops::range::RangeBounds<T>>::end_bound fn end_bound(&self) -> Bound<&T> {
Included(self.end)
}
<core::ops::range::RangeInclusive<&T> as core::ops::range::RangeBounds<T>>::start_bound fn start_bound(&self) -> Bound<&T> {
Included(self.start)
}
<core::ops::range::RangeInclusive<T> as core::ops::range::IntoBounds<T>>::into_bounds fn into_bounds(self) -> (Bound<T>, Bound<T>) {
(
Included(self.start),
if self.exhausted {
// When the iterator is exhausted, we usually have start == end,
// but we want the range to appear empty, containing nothing.
Excluded(self.end)
} else {
Included(self.end)
},
)
}
<core::ops::range::RangeInclusive<T> as core::ops::range::RangeBounds<T>>::end_bound fn end_bound(&self) -> Bound<&T> {
if self.exhausted {
// When the iterator is exhausted, we usually have start == end,
// but we want the range to appear empty, containing nothing.
Excluded(&self.end)
} else {
Included(&self.end)
}
}
<core::ops::range::RangeInclusive<T> as core::ops::range::RangeBounds<T>>::start_bound fn start_bound(&self) -> Bound<&T> {
Included(&self.start)
}
<core::ops::range::RangeTo<&T> as core::ops::range::RangeBounds<T>>::end_bound fn end_bound(&self) -> Bound<&T> {
Excluded(self.end)
}
<core::ops::range::RangeTo<&T> as core::ops::range::RangeBounds<T>>::start_bound fn start_bound(&self) -> Bound<&T> {
Unbounded
}
<core::ops::range::RangeTo<T> as core::ops::range::IntoBounds<T>>::into_bounds fn into_bounds(self) -> (Bound<T>, Bound<T>) {
(Unbounded, Excluded(self.end))
}
<core::ops::range::RangeTo<T> as core::ops::range::OneSidedRange<T>>::bound fn bound(self) -> (OneSidedRangeBound, T) {
(OneSidedRangeBound::End, self.end)
}
<core::ops::range::RangeTo<T> as core::ops::range::RangeBounds<T>>::end_bound fn end_bound(&self) -> Bound<&T> {
Excluded(&self.end)
}
<core::ops::range::RangeTo<T> as core::ops::range::RangeBounds<T>>::start_bound fn start_bound(&self) -> Bound<&T> {
Unbounded
}
<core::ops::range::RangeToInclusive<&T> as core::ops::range::RangeBounds<T>>::end_bound fn end_bound(&self) -> Bound<&T> {
Included(self.end)
}
<core::ops::range::RangeToInclusive<&T> as core::ops::range::RangeBounds<T>>::start_bound fn start_bound(&self) -> Bound<&T> {
Unbounded
}
<core::ops::range::RangeToInclusive<T> as core::ops::range::IntoBounds<T>>::into_bounds fn into_bounds(self) -> (Bound<T>, Bound<T>) {
(Unbounded, Included(self.end))
}
<core::ops::range::RangeToInclusive<T> as core::ops::range::OneSidedRange<T>>::bound fn bound(self) -> (OneSidedRangeBound, T) {
(OneSidedRangeBound::EndInclusive, self.end)
}
<core::ops::range::RangeToInclusive<T> as core::ops::range::RangeBounds<T>>::end_bound fn end_bound(&self) -> Bound<&T> {
Included(&self.end)
}
<core::ops::range::RangeToInclusive<T> as core::ops::range::RangeBounds<T>>::start_bound fn start_bound(&self) -> Bound<&T> {
Unbounded
}
<core::option::Option<&'a T> as core::convert::From<&'a core::option::Option<T>>>::from fn from(o: &'a Option<T>) -> Option<&'a T> {
o.as_ref()
}
<core::option::Option<&'a mut T> as core::convert::From<&'a mut core::option::Option<T>>>::from fn from(o: &'a mut Option<T>) -> Option<&'a mut T> {
o.as_mut()
}
<core::option::Option<T> as core::clone::Clone>::clone fn clone(&self) -> Self {
match self {
Some(x) => Some(x.clone()),
None => None,
}
}
<core::option::Option<T> as core::clone::Clone>::clone_from fn clone_from(&mut self, source: &Self) {
match (self, source) {
(Some(to), Some(from)) => to.clone_from(from),
(to, from) => *to = from.clone(),
}
}
<core::option::Option<T> as core::convert::From<T>>::from fn from(val: T) -> Option<T> {
Some(val)
}
<core::option::Option<T> as core::default::Default>::default fn default() -> Option<T> {
None
}
<core::sync::atomic::AtomicU32 as core::convert::From<u32>>::from fn from(v: $int_type) -> Self { Self::new(v) }
<core::sync::atomic::AtomicU32 as core::default::Default>::default fn default() -> Self {
Self::new(Default::default())
}
<f32 as core::ops::arith::Add<&f32>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<f32 as core::ops::arith::Add>::add fn add(self, other: $t) -> $t { self + other }
<f32 as core::ops::arith::AddAssign<&f32>>::add_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<f32 as core::ops::arith::AddAssign>::add_assign fn add_assign(&mut self, other: $t) { *self += other }
<f32 as core::ops::arith::Div<&f32>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<f32 as core::ops::arith::Div>::div fn div(self, other: $t) -> $t { self / other }
<f32 as core::ops::arith::DivAssign<&f32>>::div_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<f32 as core::ops::arith::DivAssign>::div_assign fn div_assign(&mut self, other: $t) { *self /= other }
<f32 as core::ops::arith::Mul<&f32>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<f32 as core::ops::arith::Mul>::mul fn mul(self, other: $t) -> $t { self * other }
<f32 as core::ops::arith::MulAssign<&f32>>::mul_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<f32 as core::ops::arith::MulAssign>::mul_assign fn mul_assign(&mut self, other: $t) { *self *= other }
<f32 as core::ops::arith::Neg>::neg fn neg(self) -> $t { -self }
<f32 as core::ops::arith::Rem<&f32>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<f32 as core::ops::arith::Rem>::rem fn rem(self, other: $t) -> $t { self % other }
<f32 as core::ops::arith::RemAssign<&f32>>::rem_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<f32 as core::ops::arith::RemAssign>::rem_assign fn rem_assign(&mut self, other: $t) { *self %= other }
<f32 as core::ops::arith::Sub<&f32>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<f32 as core::ops::arith::Sub>::sub fn sub(self, other: $t) -> $t { self - other }
<f32 as core::ops::arith::SubAssign<&f32>>::sub_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<f32 as core::ops::arith::SubAssign>::sub_assign fn sub_assign(&mut self, other: $t) { *self -= other }
<f64 as core::ops::arith::Add<&f64>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<f64 as core::ops::arith::Add>::add fn add(self, other: $t) -> $t { self + other }
<f64 as core::ops::arith::AddAssign<&f64>>::add_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<f64 as core::ops::arith::AddAssign>::add_assign fn add_assign(&mut self, other: $t) { *self += other }
<f64 as core::ops::arith::Div<&f64>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<f64 as core::ops::arith::Div>::div fn div(self, other: $t) -> $t { self / other }
<f64 as core::ops::arith::DivAssign<&f64>>::div_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<f64 as core::ops::arith::DivAssign>::div_assign fn div_assign(&mut self, other: $t) { *self /= other }
<f64 as core::ops::arith::Mul<&f64>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<f64 as core::ops::arith::Mul>::mul fn mul(self, other: $t) -> $t { self * other }
<f64 as core::ops::arith::MulAssign<&f64>>::mul_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<f64 as core::ops::arith::MulAssign>::mul_assign fn mul_assign(&mut self, other: $t) { *self *= other }
<f64 as core::ops::arith::Neg>::neg fn neg(self) -> $t { -self }
<f64 as core::ops::arith::Rem<&f64>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<f64 as core::ops::arith::Rem>::rem fn rem(self, other: $t) -> $t { self % other }
<f64 as core::ops::arith::RemAssign<&f64>>::rem_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<f64 as core::ops::arith::RemAssign>::rem_assign fn rem_assign(&mut self, other: $t) { *self %= other }
<f64 as core::ops::arith::Sub<&f64>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<f64 as core::ops::arith::Sub>::sub fn sub(self, other: $t) -> $t { self - other }
<f64 as core::ops::arith::SubAssign<&f64>>::sub_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<f64 as core::ops::arith::SubAssign>::sub_assign fn sub_assign(&mut self, other: $t) { *self -= other }
<i128 as core::ops::arith::Add<&i128>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::arith::Add>::add fn add(self, other: $t) -> $t { self + other }
<i128 as core::ops::arith::AddAssign<&i128>>::add_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::arith::AddAssign>::add_assign fn add_assign(&mut self, other: $t) { *self += other }
<i128 as core::ops::arith::Div<&i128>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::arith::Div>::div fn div(self, other: $t) -> $t { self / other }
<i128 as core::ops::arith::DivAssign<&i128>>::div_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::arith::DivAssign>::div_assign fn div_assign(&mut self, other: $t) { *self /= other }
<i128 as core::ops::arith::Mul<&i128>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::arith::Mul>::mul fn mul(self, other: $t) -> $t { self * other }
<i128 as core::ops::arith::MulAssign<&i128>>::mul_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::arith::MulAssign>::mul_assign fn mul_assign(&mut self, other: $t) { *self *= other }
<i128 as core::ops::arith::Neg>::neg fn neg(self) -> $t { -self }
<i128 as core::ops::arith::Rem<&i128>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::arith::Rem>::rem fn rem(self, other: $t) -> $t { self % other }
<i128 as core::ops::arith::RemAssign<&i128>>::rem_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::arith::RemAssign>::rem_assign fn rem_assign(&mut self, other: $t) { *self %= other }
<i128 as core::ops::arith::Sub<&i128>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::arith::Sub>::sub fn sub(self, other: $t) -> $t { self - other }
<i128 as core::ops::arith::SubAssign<&i128>>::sub_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::arith::SubAssign>::sub_assign fn sub_assign(&mut self, other: $t) { *self -= other }
<i128 as core::ops::bit::BitAnd<&i128>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::BitAnd>::bitand fn bitand(self, rhs: $t) -> $t { self & rhs }
<i128 as core::ops::bit::BitAndAssign<&i128>>::bitand_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::BitAndAssign>::bitand_assign fn bitand_assign(&mut self, other: $t) { *self &= other }
<i128 as core::ops::bit::BitOr<&i128>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::BitOr>::bitor fn bitor(self, rhs: $t) -> $t { self | rhs }
<i128 as core::ops::bit::BitOrAssign<&i128>>::bitor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::BitOrAssign>::bitor_assign fn bitor_assign(&mut self, other: $t) { *self |= other }
<i128 as core::ops::bit::BitXor<&i128>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::BitXor>::bitxor fn bitxor(self, other: $t) -> $t { self ^ other }
<i128 as core::ops::bit::BitXorAssign<&i128>>::bitxor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::BitXorAssign>::bitxor_assign fn bitxor_assign(&mut self, other: $t) { *self ^= other }
<i128 as core::ops::bit::Not>::not fn not(self) -> $t { !self }
<i128 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shl<i16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i128 as core::ops::bit::Shl<i32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i128 as core::ops::bit::Shl<i64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i128 as core::ops::bit::Shl<i8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i128 as core::ops::bit::Shl<isize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i128 as core::ops::bit::Shl<u128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i128 as core::ops::bit::Shl<u16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i128 as core::ops::bit::Shl<u32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i128 as core::ops::bit::Shl<u64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i128 as core::ops::bit::Shl<u8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i128 as core::ops::bit::Shl<usize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i128 as core::ops::bit::Shl>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i128 as core::ops::bit::ShlAssign<&i128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShlAssign<&i16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShlAssign<&i32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShlAssign<&i64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShlAssign<&i8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShlAssign<&isize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShlAssign<&u128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShlAssign<&u16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShlAssign<&u32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShlAssign<&u64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShlAssign<&u8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShlAssign<&usize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShlAssign<i16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i128 as core::ops::bit::ShlAssign<i32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i128 as core::ops::bit::ShlAssign<i64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i128 as core::ops::bit::ShlAssign<i8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i128 as core::ops::bit::ShlAssign<isize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i128 as core::ops::bit::ShlAssign<u128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i128 as core::ops::bit::ShlAssign<u16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i128 as core::ops::bit::ShlAssign<u32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i128 as core::ops::bit::ShlAssign<u64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i128 as core::ops::bit::ShlAssign<u8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i128 as core::ops::bit::ShlAssign<usize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i128 as core::ops::bit::ShlAssign>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i128 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i128 as core::ops::bit::Shr<i16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i128 as core::ops::bit::Shr<i32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i128 as core::ops::bit::Shr<i64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i128 as core::ops::bit::Shr<i8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i128 as core::ops::bit::Shr<isize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i128 as core::ops::bit::Shr<u128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i128 as core::ops::bit::Shr<u16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i128 as core::ops::bit::Shr<u32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i128 as core::ops::bit::Shr<u64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i128 as core::ops::bit::Shr<u8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i128 as core::ops::bit::Shr<usize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i128 as core::ops::bit::Shr>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i128 as core::ops::bit::ShrAssign<&i128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShrAssign<&i16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShrAssign<&i32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShrAssign<&i64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShrAssign<&i8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShrAssign<&isize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShrAssign<&u128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShrAssign<&u16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShrAssign<&u32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShrAssign<&u64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShrAssign<&u8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShrAssign<&usize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i128 as core::ops::bit::ShrAssign<i16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i128 as core::ops::bit::ShrAssign<i32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i128 as core::ops::bit::ShrAssign<i64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i128 as core::ops::bit::ShrAssign<i8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i128 as core::ops::bit::ShrAssign<isize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i128 as core::ops::bit::ShrAssign<u128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i128 as core::ops::bit::ShrAssign<u16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i128 as core::ops::bit::ShrAssign<u32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i128 as core::ops::bit::ShrAssign<u64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i128 as core::ops::bit::ShrAssign<u8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i128 as core::ops::bit::ShrAssign<usize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i128 as core::ops::bit::ShrAssign>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i16 as core::ops::arith::Add<&i16>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::arith::Add>::add fn add(self, other: $t) -> $t { self + other }
<i16 as core::ops::arith::AddAssign<&i16>>::add_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::arith::AddAssign>::add_assign fn add_assign(&mut self, other: $t) { *self += other }
<i16 as core::ops::arith::Div<&i16>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::arith::Div>::div fn div(self, other: $t) -> $t { self / other }
<i16 as core::ops::arith::DivAssign<&i16>>::div_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::arith::DivAssign>::div_assign fn div_assign(&mut self, other: $t) { *self /= other }
<i16 as core::ops::arith::Mul<&i16>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::arith::Mul>::mul fn mul(self, other: $t) -> $t { self * other }
<i16 as core::ops::arith::MulAssign<&i16>>::mul_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::arith::MulAssign>::mul_assign fn mul_assign(&mut self, other: $t) { *self *= other }
<i16 as core::ops::arith::Neg>::neg fn neg(self) -> $t { -self }
<i16 as core::ops::arith::Rem<&i16>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::arith::Rem>::rem fn rem(self, other: $t) -> $t { self % other }
<i16 as core::ops::arith::RemAssign<&i16>>::rem_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::arith::RemAssign>::rem_assign fn rem_assign(&mut self, other: $t) { *self %= other }
<i16 as core::ops::arith::Sub<&i16>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::arith::Sub>::sub fn sub(self, other: $t) -> $t { self - other }
<i16 as core::ops::arith::SubAssign<&i16>>::sub_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::arith::SubAssign>::sub_assign fn sub_assign(&mut self, other: $t) { *self -= other }
<i16 as core::ops::bit::BitAnd<&i16>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::BitAnd>::bitand fn bitand(self, rhs: $t) -> $t { self & rhs }
<i16 as core::ops::bit::BitAndAssign<&i16>>::bitand_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::BitAndAssign>::bitand_assign fn bitand_assign(&mut self, other: $t) { *self &= other }
<i16 as core::ops::bit::BitOr<&i16>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::BitOr>::bitor fn bitor(self, rhs: $t) -> $t { self | rhs }
<i16 as core::ops::bit::BitOrAssign<&i16>>::bitor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::BitOrAssign>::bitor_assign fn bitor_assign(&mut self, other: $t) { *self |= other }
<i16 as core::ops::bit::BitXor<&i16>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::BitXor>::bitxor fn bitxor(self, other: $t) -> $t { self ^ other }
<i16 as core::ops::bit::BitXorAssign<&i16>>::bitxor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::BitXorAssign>::bitxor_assign fn bitxor_assign(&mut self, other: $t) { *self ^= other }
<i16 as core::ops::bit::Not>::not fn not(self) -> $t { !self }
<i16 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shl<i128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i16 as core::ops::bit::Shl<i32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i16 as core::ops::bit::Shl<i64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i16 as core::ops::bit::Shl<i8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i16 as core::ops::bit::Shl<isize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i16 as core::ops::bit::Shl<u128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i16 as core::ops::bit::Shl<u16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i16 as core::ops::bit::Shl<u32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i16 as core::ops::bit::Shl<u64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i16 as core::ops::bit::Shl<u8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i16 as core::ops::bit::Shl<usize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i16 as core::ops::bit::Shl>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i16 as core::ops::bit::ShlAssign<&i128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShlAssign<&i16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShlAssign<&i32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShlAssign<&i64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShlAssign<&i8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShlAssign<&isize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShlAssign<&u128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShlAssign<&u16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShlAssign<&u32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShlAssign<&u64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShlAssign<&u8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShlAssign<&usize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShlAssign<i128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i16 as core::ops::bit::ShlAssign<i32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i16 as core::ops::bit::ShlAssign<i64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i16 as core::ops::bit::ShlAssign<i8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i16 as core::ops::bit::ShlAssign<isize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i16 as core::ops::bit::ShlAssign<u128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i16 as core::ops::bit::ShlAssign<u16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i16 as core::ops::bit::ShlAssign<u32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i16 as core::ops::bit::ShlAssign<u64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i16 as core::ops::bit::ShlAssign<u8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i16 as core::ops::bit::ShlAssign<usize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i16 as core::ops::bit::ShlAssign>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i16 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i16 as core::ops::bit::Shr<i128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i16 as core::ops::bit::Shr<i32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i16 as core::ops::bit::Shr<i64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i16 as core::ops::bit::Shr<i8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i16 as core::ops::bit::Shr<isize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i16 as core::ops::bit::Shr<u128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i16 as core::ops::bit::Shr<u16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i16 as core::ops::bit::Shr<u32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i16 as core::ops::bit::Shr<u64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i16 as core::ops::bit::Shr<u8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i16 as core::ops::bit::Shr<usize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i16 as core::ops::bit::Shr>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i16 as core::ops::bit::ShrAssign<&i128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShrAssign<&i16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShrAssign<&i32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShrAssign<&i64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShrAssign<&i8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShrAssign<&isize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShrAssign<&u128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShrAssign<&u16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShrAssign<&u32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShrAssign<&u64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShrAssign<&u8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShrAssign<&usize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i16 as core::ops::bit::ShrAssign<i128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i16 as core::ops::bit::ShrAssign<i32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i16 as core::ops::bit::ShrAssign<i64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i16 as core::ops::bit::ShrAssign<i8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i16 as core::ops::bit::ShrAssign<isize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i16 as core::ops::bit::ShrAssign<u128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i16 as core::ops::bit::ShrAssign<u16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i16 as core::ops::bit::ShrAssign<u32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i16 as core::ops::bit::ShrAssign<u64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i16 as core::ops::bit::ShrAssign<u8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i16 as core::ops::bit::ShrAssign<usize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i16 as core::ops::bit::ShrAssign>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i32 as core::ops::arith::Add<&i32>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::arith::Add>::add fn add(self, other: $t) -> $t { self + other }
<i32 as core::ops::arith::AddAssign<&i32>>::add_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::arith::AddAssign>::add_assign fn add_assign(&mut self, other: $t) { *self += other }
<i32 as core::ops::arith::Div<&i32>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::arith::Div>::div fn div(self, other: $t) -> $t { self / other }
<i32 as core::ops::arith::DivAssign<&i32>>::div_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::arith::DivAssign>::div_assign fn div_assign(&mut self, other: $t) { *self /= other }
<i32 as core::ops::arith::Mul<&i32>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::arith::Mul>::mul fn mul(self, other: $t) -> $t { self * other }
<i32 as core::ops::arith::MulAssign<&i32>>::mul_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::arith::MulAssign>::mul_assign fn mul_assign(&mut self, other: $t) { *self *= other }
<i32 as core::ops::arith::Neg>::neg fn neg(self) -> $t { -self }
<i32 as core::ops::arith::Rem<&i32>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::arith::Rem>::rem fn rem(self, other: $t) -> $t { self % other }
<i32 as core::ops::arith::RemAssign<&i32>>::rem_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::arith::RemAssign>::rem_assign fn rem_assign(&mut self, other: $t) { *self %= other }
<i32 as core::ops::arith::Sub<&i32>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::arith::Sub>::sub fn sub(self, other: $t) -> $t { self - other }
<i32 as core::ops::arith::SubAssign<&i32>>::sub_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::arith::SubAssign>::sub_assign fn sub_assign(&mut self, other: $t) { *self -= other }
<i32 as core::ops::bit::BitAnd<&i32>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::BitAnd>::bitand fn bitand(self, rhs: $t) -> $t { self & rhs }
<i32 as core::ops::bit::BitAndAssign<&i32>>::bitand_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::BitAndAssign>::bitand_assign fn bitand_assign(&mut self, other: $t) { *self &= other }
<i32 as core::ops::bit::BitOr<&i32>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::BitOr>::bitor fn bitor(self, rhs: $t) -> $t { self | rhs }
<i32 as core::ops::bit::BitOrAssign<&i32>>::bitor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::BitOrAssign>::bitor_assign fn bitor_assign(&mut self, other: $t) { *self |= other }
<i32 as core::ops::bit::BitXor<&i32>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::BitXor>::bitxor fn bitxor(self, other: $t) -> $t { self ^ other }
<i32 as core::ops::bit::BitXorAssign<&i32>>::bitxor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::BitXorAssign>::bitxor_assign fn bitxor_assign(&mut self, other: $t) { *self ^= other }
<i32 as core::ops::bit::Not>::not fn not(self) -> $t { !self }
<i32 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shl<i128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i32 as core::ops::bit::Shl<i16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i32 as core::ops::bit::Shl<i64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i32 as core::ops::bit::Shl<i8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i32 as core::ops::bit::Shl<isize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i32 as core::ops::bit::Shl<u128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i32 as core::ops::bit::Shl<u16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i32 as core::ops::bit::Shl<u32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i32 as core::ops::bit::Shl<u64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i32 as core::ops::bit::Shl<u8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i32 as core::ops::bit::Shl<usize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i32 as core::ops::bit::Shl>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i32 as core::ops::bit::ShlAssign<&i128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShlAssign<&i16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShlAssign<&i32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShlAssign<&i64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShlAssign<&i8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShlAssign<&isize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShlAssign<&u128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShlAssign<&u16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShlAssign<&u32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShlAssign<&u64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShlAssign<&u8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShlAssign<&usize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShlAssign<i128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i32 as core::ops::bit::ShlAssign<i16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i32 as core::ops::bit::ShlAssign<i64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i32 as core::ops::bit::ShlAssign<i8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i32 as core::ops::bit::ShlAssign<isize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i32 as core::ops::bit::ShlAssign<u128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i32 as core::ops::bit::ShlAssign<u16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i32 as core::ops::bit::ShlAssign<u32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i32 as core::ops::bit::ShlAssign<u64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i32 as core::ops::bit::ShlAssign<u8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i32 as core::ops::bit::ShlAssign<usize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i32 as core::ops::bit::ShlAssign>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i32 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i32 as core::ops::bit::Shr<i128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i32 as core::ops::bit::Shr<i16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i32 as core::ops::bit::Shr<i64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i32 as core::ops::bit::Shr<i8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i32 as core::ops::bit::Shr<isize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i32 as core::ops::bit::Shr<u128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i32 as core::ops::bit::Shr<u16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i32 as core::ops::bit::Shr<u32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i32 as core::ops::bit::Shr<u64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i32 as core::ops::bit::Shr<u8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i32 as core::ops::bit::Shr<usize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i32 as core::ops::bit::Shr>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i32 as core::ops::bit::ShrAssign<&i128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShrAssign<&i16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShrAssign<&i32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShrAssign<&i64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShrAssign<&i8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShrAssign<&isize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShrAssign<&u128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShrAssign<&u16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShrAssign<&u32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShrAssign<&u64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShrAssign<&u8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShrAssign<&usize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i32 as core::ops::bit::ShrAssign<i128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i32 as core::ops::bit::ShrAssign<i16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i32 as core::ops::bit::ShrAssign<i64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i32 as core::ops::bit::ShrAssign<i8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i32 as core::ops::bit::ShrAssign<isize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i32 as core::ops::bit::ShrAssign<u128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i32 as core::ops::bit::ShrAssign<u16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i32 as core::ops::bit::ShrAssign<u32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i32 as core::ops::bit::ShrAssign<u64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i32 as core::ops::bit::ShrAssign<u8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i32 as core::ops::bit::ShrAssign<usize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i32 as core::ops::bit::ShrAssign>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i64 as core::ops::arith::Add<&i64>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::arith::Add>::add fn add(self, other: $t) -> $t { self + other }
<i64 as core::ops::arith::AddAssign<&i64>>::add_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::arith::AddAssign>::add_assign fn add_assign(&mut self, other: $t) { *self += other }
<i64 as core::ops::arith::Div<&i64>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::arith::Div>::div fn div(self, other: $t) -> $t { self / other }
<i64 as core::ops::arith::DivAssign<&i64>>::div_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::arith::DivAssign>::div_assign fn div_assign(&mut self, other: $t) { *self /= other }
<i64 as core::ops::arith::Mul<&i64>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::arith::Mul>::mul fn mul(self, other: $t) -> $t { self * other }
<i64 as core::ops::arith::MulAssign<&i64>>::mul_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::arith::MulAssign>::mul_assign fn mul_assign(&mut self, other: $t) { *self *= other }
<i64 as core::ops::arith::Neg>::neg fn neg(self) -> $t { -self }
<i64 as core::ops::arith::Rem<&i64>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::arith::Rem>::rem fn rem(self, other: $t) -> $t { self % other }
<i64 as core::ops::arith::RemAssign<&i64>>::rem_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::arith::RemAssign>::rem_assign fn rem_assign(&mut self, other: $t) { *self %= other }
<i64 as core::ops::arith::Sub<&i64>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::arith::Sub>::sub fn sub(self, other: $t) -> $t { self - other }
<i64 as core::ops::arith::SubAssign<&i64>>::sub_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::arith::SubAssign>::sub_assign fn sub_assign(&mut self, other: $t) { *self -= other }
<i64 as core::ops::bit::BitAnd<&i64>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::BitAnd>::bitand fn bitand(self, rhs: $t) -> $t { self & rhs }
<i64 as core::ops::bit::BitAndAssign<&i64>>::bitand_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::BitAndAssign>::bitand_assign fn bitand_assign(&mut self, other: $t) { *self &= other }
<i64 as core::ops::bit::BitOr<&i64>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::BitOr>::bitor fn bitor(self, rhs: $t) -> $t { self | rhs }
<i64 as core::ops::bit::BitOrAssign<&i64>>::bitor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::BitOrAssign>::bitor_assign fn bitor_assign(&mut self, other: $t) { *self |= other }
<i64 as core::ops::bit::BitXor<&i64>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::BitXor>::bitxor fn bitxor(self, other: $t) -> $t { self ^ other }
<i64 as core::ops::bit::BitXorAssign<&i64>>::bitxor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::BitXorAssign>::bitxor_assign fn bitxor_assign(&mut self, other: $t) { *self ^= other }
<i64 as core::ops::bit::Not>::not fn not(self) -> $t { !self }
<i64 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shl<i128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i64 as core::ops::bit::Shl<i16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i64 as core::ops::bit::Shl<i32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i64 as core::ops::bit::Shl<i8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i64 as core::ops::bit::Shl<isize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i64 as core::ops::bit::Shl<u128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i64 as core::ops::bit::Shl<u16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i64 as core::ops::bit::Shl<u32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i64 as core::ops::bit::Shl<u64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i64 as core::ops::bit::Shl<u8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i64 as core::ops::bit::Shl<usize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i64 as core::ops::bit::Shl>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i64 as core::ops::bit::ShlAssign<&i128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShlAssign<&i16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShlAssign<&i32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShlAssign<&i64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShlAssign<&i8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShlAssign<&isize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShlAssign<&u128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShlAssign<&u16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShlAssign<&u32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShlAssign<&u64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShlAssign<&u8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShlAssign<&usize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShlAssign<i128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i64 as core::ops::bit::ShlAssign<i16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i64 as core::ops::bit::ShlAssign<i32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i64 as core::ops::bit::ShlAssign<i8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i64 as core::ops::bit::ShlAssign<isize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i64 as core::ops::bit::ShlAssign<u128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i64 as core::ops::bit::ShlAssign<u16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i64 as core::ops::bit::ShlAssign<u32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i64 as core::ops::bit::ShlAssign<u64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i64 as core::ops::bit::ShlAssign<u8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i64 as core::ops::bit::ShlAssign<usize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i64 as core::ops::bit::ShlAssign>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i64 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i64 as core::ops::bit::Shr<i128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i64 as core::ops::bit::Shr<i16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i64 as core::ops::bit::Shr<i32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i64 as core::ops::bit::Shr<i8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i64 as core::ops::bit::Shr<isize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i64 as core::ops::bit::Shr<u128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i64 as core::ops::bit::Shr<u16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i64 as core::ops::bit::Shr<u32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i64 as core::ops::bit::Shr<u64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i64 as core::ops::bit::Shr<u8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i64 as core::ops::bit::Shr<usize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i64 as core::ops::bit::Shr>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i64 as core::ops::bit::ShrAssign<&i128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShrAssign<&i16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShrAssign<&i32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShrAssign<&i64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShrAssign<&i8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShrAssign<&isize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShrAssign<&u128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShrAssign<&u16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShrAssign<&u32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShrAssign<&u64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShrAssign<&u8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShrAssign<&usize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i64 as core::ops::bit::ShrAssign<i128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i64 as core::ops::bit::ShrAssign<i16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i64 as core::ops::bit::ShrAssign<i32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i64 as core::ops::bit::ShrAssign<i8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i64 as core::ops::bit::ShrAssign<isize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i64 as core::ops::bit::ShrAssign<u128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i64 as core::ops::bit::ShrAssign<u16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i64 as core::ops::bit::ShrAssign<u32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i64 as core::ops::bit::ShrAssign<u64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i64 as core::ops::bit::ShrAssign<u8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i64 as core::ops::bit::ShrAssign<usize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i64 as core::ops::bit::ShrAssign>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i8 as core::ops::arith::Add<&i8>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::arith::Add>::add fn add(self, other: $t) -> $t { self + other }
<i8 as core::ops::arith::AddAssign<&i8>>::add_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::arith::AddAssign>::add_assign fn add_assign(&mut self, other: $t) { *self += other }
<i8 as core::ops::arith::Div<&i8>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::arith::Div>::div fn div(self, other: $t) -> $t { self / other }
<i8 as core::ops::arith::DivAssign<&i8>>::div_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::arith::DivAssign>::div_assign fn div_assign(&mut self, other: $t) { *self /= other }
<i8 as core::ops::arith::Mul<&i8>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::arith::Mul>::mul fn mul(self, other: $t) -> $t { self * other }
<i8 as core::ops::arith::MulAssign<&i8>>::mul_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::arith::MulAssign>::mul_assign fn mul_assign(&mut self, other: $t) { *self *= other }
<i8 as core::ops::arith::Neg>::neg fn neg(self) -> $t { -self }
<i8 as core::ops::arith::Rem<&i8>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::arith::Rem>::rem fn rem(self, other: $t) -> $t { self % other }
<i8 as core::ops::arith::RemAssign<&i8>>::rem_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::arith::RemAssign>::rem_assign fn rem_assign(&mut self, other: $t) { *self %= other }
<i8 as core::ops::arith::Sub<&i8>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::arith::Sub>::sub fn sub(self, other: $t) -> $t { self - other }
<i8 as core::ops::arith::SubAssign<&i8>>::sub_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::arith::SubAssign>::sub_assign fn sub_assign(&mut self, other: $t) { *self -= other }
<i8 as core::ops::bit::BitAnd<&i8>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::BitAnd>::bitand fn bitand(self, rhs: $t) -> $t { self & rhs }
<i8 as core::ops::bit::BitAndAssign<&i8>>::bitand_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::BitAndAssign>::bitand_assign fn bitand_assign(&mut self, other: $t) { *self &= other }
<i8 as core::ops::bit::BitOr<&i8>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::BitOr>::bitor fn bitor(self, rhs: $t) -> $t { self | rhs }
<i8 as core::ops::bit::BitOrAssign<&i8>>::bitor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::BitOrAssign>::bitor_assign fn bitor_assign(&mut self, other: $t) { *self |= other }
<i8 as core::ops::bit::BitXor<&i8>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::BitXor>::bitxor fn bitxor(self, other: $t) -> $t { self ^ other }
<i8 as core::ops::bit::BitXorAssign<&i8>>::bitxor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::BitXorAssign>::bitxor_assign fn bitxor_assign(&mut self, other: $t) { *self ^= other }
<i8 as core::ops::bit::Not>::not fn not(self) -> $t { !self }
<i8 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shl<i128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i8 as core::ops::bit::Shl<i16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i8 as core::ops::bit::Shl<i32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i8 as core::ops::bit::Shl<i64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i8 as core::ops::bit::Shl<isize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i8 as core::ops::bit::Shl<u128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i8 as core::ops::bit::Shl<u16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i8 as core::ops::bit::Shl<u32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i8 as core::ops::bit::Shl<u64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i8 as core::ops::bit::Shl<u8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i8 as core::ops::bit::Shl<usize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i8 as core::ops::bit::Shl>::shl fn shl(self, other: $f) -> $t {
self << other
}
<i8 as core::ops::bit::ShlAssign<&i128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShlAssign<&i16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShlAssign<&i32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShlAssign<&i64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShlAssign<&i8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShlAssign<&isize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShlAssign<&u128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShlAssign<&u16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShlAssign<&u32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShlAssign<&u64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShlAssign<&u8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShlAssign<&usize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShlAssign<i128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i8 as core::ops::bit::ShlAssign<i16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i8 as core::ops::bit::ShlAssign<i32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i8 as core::ops::bit::ShlAssign<i64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i8 as core::ops::bit::ShlAssign<isize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i8 as core::ops::bit::ShlAssign<u128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i8 as core::ops::bit::ShlAssign<u16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i8 as core::ops::bit::ShlAssign<u32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i8 as core::ops::bit::ShlAssign<u64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i8 as core::ops::bit::ShlAssign<u8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i8 as core::ops::bit::ShlAssign<usize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i8 as core::ops::bit::ShlAssign>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<i8 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<i8 as core::ops::bit::Shr<i128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i8 as core::ops::bit::Shr<i16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i8 as core::ops::bit::Shr<i32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i8 as core::ops::bit::Shr<i64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i8 as core::ops::bit::Shr<isize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i8 as core::ops::bit::Shr<u128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i8 as core::ops::bit::Shr<u16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i8 as core::ops::bit::Shr<u32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i8 as core::ops::bit::Shr<u64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i8 as core::ops::bit::Shr<u8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i8 as core::ops::bit::Shr<usize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i8 as core::ops::bit::Shr>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<i8 as core::ops::bit::ShrAssign<&i128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShrAssign<&i16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShrAssign<&i32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShrAssign<&i64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShrAssign<&i8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShrAssign<&isize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShrAssign<&u128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShrAssign<&u16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShrAssign<&u32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShrAssign<&u64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShrAssign<&u8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShrAssign<&usize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<i8 as core::ops::bit::ShrAssign<i128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i8 as core::ops::bit::ShrAssign<i16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i8 as core::ops::bit::ShrAssign<i32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i8 as core::ops::bit::ShrAssign<i64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i8 as core::ops::bit::ShrAssign<isize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i8 as core::ops::bit::ShrAssign<u128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i8 as core::ops::bit::ShrAssign<u16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i8 as core::ops::bit::ShrAssign<u32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i8 as core::ops::bit::ShrAssign<u64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i8 as core::ops::bit::ShrAssign<u8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i8 as core::ops::bit::ShrAssign<usize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<i8 as core::ops::bit::ShrAssign>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<isize as core::ops::arith::Add<&isize>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::arith::Add>::add fn add(self, other: $t) -> $t { self + other }
<isize as core::ops::arith::AddAssign<&isize>>::add_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::arith::AddAssign>::add_assign fn add_assign(&mut self, other: $t) { *self += other }
<isize as core::ops::arith::Div<&isize>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::arith::Div>::div fn div(self, other: $t) -> $t { self / other }
<isize as core::ops::arith::DivAssign<&isize>>::div_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::arith::DivAssign>::div_assign fn div_assign(&mut self, other: $t) { *self /= other }
<isize as core::ops::arith::Mul<&isize>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::arith::Mul>::mul fn mul(self, other: $t) -> $t { self * other }
<isize as core::ops::arith::MulAssign<&isize>>::mul_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::arith::MulAssign>::mul_assign fn mul_assign(&mut self, other: $t) { *self *= other }
<isize as core::ops::arith::Neg>::neg fn neg(self) -> $t { -self }
<isize as core::ops::arith::Rem<&isize>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::arith::Rem>::rem fn rem(self, other: $t) -> $t { self % other }
<isize as core::ops::arith::RemAssign<&isize>>::rem_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::arith::RemAssign>::rem_assign fn rem_assign(&mut self, other: $t) { *self %= other }
<isize as core::ops::arith::Sub<&isize>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::arith::Sub>::sub fn sub(self, other: $t) -> $t { self - other }
<isize as core::ops::arith::SubAssign<&isize>>::sub_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::arith::SubAssign>::sub_assign fn sub_assign(&mut self, other: $t) { *self -= other }
<isize as core::ops::bit::BitAnd<&isize>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::BitAnd>::bitand fn bitand(self, rhs: $t) -> $t { self & rhs }
<isize as core::ops::bit::BitAndAssign<&isize>>::bitand_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::BitAndAssign>::bitand_assign fn bitand_assign(&mut self, other: $t) { *self &= other }
<isize as core::ops::bit::BitOr<&isize>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::BitOr>::bitor fn bitor(self, rhs: $t) -> $t { self | rhs }
<isize as core::ops::bit::BitOrAssign<&isize>>::bitor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::BitOrAssign>::bitor_assign fn bitor_assign(&mut self, other: $t) { *self |= other }
<isize as core::ops::bit::BitXor<&isize>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::BitXor>::bitxor fn bitxor(self, other: $t) -> $t { self ^ other }
<isize as core::ops::bit::BitXorAssign<&isize>>::bitxor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::BitXorAssign>::bitxor_assign fn bitxor_assign(&mut self, other: $t) { *self ^= other }
<isize as core::ops::bit::Not>::not fn not(self) -> $t { !self }
<isize as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shl<i128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<isize as core::ops::bit::Shl<i16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<isize as core::ops::bit::Shl<i32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<isize as core::ops::bit::Shl<i64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<isize as core::ops::bit::Shl<i8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<isize as core::ops::bit::Shl<u128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<isize as core::ops::bit::Shl<u16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<isize as core::ops::bit::Shl<u32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<isize as core::ops::bit::Shl<u64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<isize as core::ops::bit::Shl<u8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<isize as core::ops::bit::Shl<usize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<isize as core::ops::bit::Shl>::shl fn shl(self, other: $f) -> $t {
self << other
}
<isize as core::ops::bit::ShlAssign<&i128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShlAssign<&i16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShlAssign<&i32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShlAssign<&i64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShlAssign<&i8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShlAssign<&isize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShlAssign<&u128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShlAssign<&u16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShlAssign<&u32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShlAssign<&u64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShlAssign<&u8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShlAssign<&usize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShlAssign<i128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<isize as core::ops::bit::ShlAssign<i16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<isize as core::ops::bit::ShlAssign<i32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<isize as core::ops::bit::ShlAssign<i64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<isize as core::ops::bit::ShlAssign<i8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<isize as core::ops::bit::ShlAssign<u128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<isize as core::ops::bit::ShlAssign<u16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<isize as core::ops::bit::ShlAssign<u32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<isize as core::ops::bit::ShlAssign<u64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<isize as core::ops::bit::ShlAssign<u8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<isize as core::ops::bit::ShlAssign<usize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<isize as core::ops::bit::ShlAssign>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<isize as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<isize as core::ops::bit::Shr<i128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<isize as core::ops::bit::Shr<i16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<isize as core::ops::bit::Shr<i32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<isize as core::ops::bit::Shr<i64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<isize as core::ops::bit::Shr<i8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<isize as core::ops::bit::Shr<u128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<isize as core::ops::bit::Shr<u16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<isize as core::ops::bit::Shr<u32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<isize as core::ops::bit::Shr<u64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<isize as core::ops::bit::Shr<u8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<isize as core::ops::bit::Shr<usize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<isize as core::ops::bit::Shr>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<isize as core::ops::bit::ShrAssign<&i128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShrAssign<&i16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShrAssign<&i32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShrAssign<&i64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShrAssign<&i8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShrAssign<&isize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShrAssign<&u128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShrAssign<&u16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShrAssign<&u32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShrAssign<&u64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShrAssign<&u8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShrAssign<&usize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<isize as core::ops::bit::ShrAssign<i128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<isize as core::ops::bit::ShrAssign<i16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<isize as core::ops::bit::ShrAssign<i32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<isize as core::ops::bit::ShrAssign<i64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<isize as core::ops::bit::ShrAssign<i8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<isize as core::ops::bit::ShrAssign<u128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<isize as core::ops::bit::ShrAssign<u16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<isize as core::ops::bit::ShrAssign<u32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<isize as core::ops::bit::ShrAssign<u64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<isize as core::ops::bit::ShrAssign<u8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<isize as core::ops::bit::ShrAssign<usize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<isize as core::ops::bit::ShrAssign>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<str as core::convert::AsMut<str>>::as_mut fn as_mut(&mut self) -> &mut str {
self
}
<u128 as core::ops::arith::Add<&u128>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::arith::Add>::add fn add(self, other: $t) -> $t { self + other }
<u128 as core::ops::arith::AddAssign<&u128>>::add_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::arith::AddAssign>::add_assign fn add_assign(&mut self, other: $t) { *self += other }
<u128 as core::ops::arith::Div<&u128>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::arith::Div>::div fn div(self, other: $t) -> $t { self / other }
<u128 as core::ops::arith::DivAssign<&u128>>::div_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::arith::DivAssign>::div_assign fn div_assign(&mut self, other: $t) { *self /= other }
<u128 as core::ops::arith::Mul<&u128>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::arith::Mul>::mul fn mul(self, other: $t) -> $t { self * other }
<u128 as core::ops::arith::MulAssign<&u128>>::mul_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::arith::MulAssign>::mul_assign fn mul_assign(&mut self, other: $t) { *self *= other }
<u128 as core::ops::arith::Rem<&u128>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::arith::Rem>::rem fn rem(self, other: $t) -> $t { self % other }
<u128 as core::ops::arith::RemAssign<&u128>>::rem_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::arith::RemAssign>::rem_assign fn rem_assign(&mut self, other: $t) { *self %= other }
<u128 as core::ops::arith::Sub<&u128>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::arith::Sub>::sub fn sub(self, other: $t) -> $t { self - other }
<u128 as core::ops::arith::SubAssign<&u128>>::sub_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::arith::SubAssign>::sub_assign fn sub_assign(&mut self, other: $t) { *self -= other }
<u128 as core::ops::bit::BitAnd<&u128>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::BitAnd>::bitand fn bitand(self, rhs: $t) -> $t { self & rhs }
<u128 as core::ops::bit::BitAndAssign<&u128>>::bitand_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::BitAndAssign>::bitand_assign fn bitand_assign(&mut self, other: $t) { *self &= other }
<u128 as core::ops::bit::BitOr<&u128>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::BitOr>::bitor fn bitor(self, rhs: $t) -> $t { self | rhs }
<u128 as core::ops::bit::BitOrAssign<&u128>>::bitor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::BitOrAssign>::bitor_assign fn bitor_assign(&mut self, other: $t) { *self |= other }
<u128 as core::ops::bit::BitXor<&u128>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::BitXor>::bitxor fn bitxor(self, other: $t) -> $t { self ^ other }
<u128 as core::ops::bit::BitXorAssign<&u128>>::bitxor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::BitXorAssign>::bitxor_assign fn bitxor_assign(&mut self, other: $t) { *self ^= other }
<u128 as core::ops::bit::Not>::not fn not(self) -> $t { !self }
<u128 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shl<i128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u128 as core::ops::bit::Shl<i16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u128 as core::ops::bit::Shl<i32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u128 as core::ops::bit::Shl<i64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u128 as core::ops::bit::Shl<i8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u128 as core::ops::bit::Shl<isize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u128 as core::ops::bit::Shl<u16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u128 as core::ops::bit::Shl<u32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u128 as core::ops::bit::Shl<u64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u128 as core::ops::bit::Shl<u8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u128 as core::ops::bit::Shl<usize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u128 as core::ops::bit::Shl>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u128 as core::ops::bit::ShlAssign<&i128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShlAssign<&i16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShlAssign<&i32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShlAssign<&i64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShlAssign<&i8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShlAssign<&isize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShlAssign<&u128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShlAssign<&u16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShlAssign<&u32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShlAssign<&u64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShlAssign<&u8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShlAssign<&usize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShlAssign<i128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u128 as core::ops::bit::ShlAssign<i16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u128 as core::ops::bit::ShlAssign<i32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u128 as core::ops::bit::ShlAssign<i64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u128 as core::ops::bit::ShlAssign<i8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u128 as core::ops::bit::ShlAssign<isize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u128 as core::ops::bit::ShlAssign<u16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u128 as core::ops::bit::ShlAssign<u32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u128 as core::ops::bit::ShlAssign<u64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u128 as core::ops::bit::ShlAssign<u8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u128 as core::ops::bit::ShlAssign<usize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u128 as core::ops::bit::ShlAssign>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u128 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u128 as core::ops::bit::Shr<i128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u128 as core::ops::bit::Shr<i16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u128 as core::ops::bit::Shr<i32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u128 as core::ops::bit::Shr<i64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u128 as core::ops::bit::Shr<i8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u128 as core::ops::bit::Shr<isize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u128 as core::ops::bit::Shr<u16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u128 as core::ops::bit::Shr<u32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u128 as core::ops::bit::Shr<u64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u128 as core::ops::bit::Shr<u8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u128 as core::ops::bit::Shr<usize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u128 as core::ops::bit::Shr>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u128 as core::ops::bit::ShrAssign<&i128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShrAssign<&i16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShrAssign<&i32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShrAssign<&i64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShrAssign<&i8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShrAssign<&isize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShrAssign<&u128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShrAssign<&u16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShrAssign<&u32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShrAssign<&u64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShrAssign<&u8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShrAssign<&usize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u128 as core::ops::bit::ShrAssign<i128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u128 as core::ops::bit::ShrAssign<i16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u128 as core::ops::bit::ShrAssign<i32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u128 as core::ops::bit::ShrAssign<i64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u128 as core::ops::bit::ShrAssign<i8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u128 as core::ops::bit::ShrAssign<isize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u128 as core::ops::bit::ShrAssign<u16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u128 as core::ops::bit::ShrAssign<u32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u128 as core::ops::bit::ShrAssign<u64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u128 as core::ops::bit::ShrAssign<u8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u128 as core::ops::bit::ShrAssign<usize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u128 as core::ops::bit::ShrAssign>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u16 as core::ops::arith::Add<&u16>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::arith::Add>::add fn add(self, other: $t) -> $t { self + other }
<u16 as core::ops::arith::AddAssign<&u16>>::add_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::arith::AddAssign>::add_assign fn add_assign(&mut self, other: $t) { *self += other }
<u16 as core::ops::arith::Div<&u16>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::arith::Div>::div fn div(self, other: $t) -> $t { self / other }
<u16 as core::ops::arith::DivAssign<&u16>>::div_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::arith::DivAssign>::div_assign fn div_assign(&mut self, other: $t) { *self /= other }
<u16 as core::ops::arith::Mul<&u16>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::arith::Mul>::mul fn mul(self, other: $t) -> $t { self * other }
<u16 as core::ops::arith::MulAssign<&u16>>::mul_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::arith::MulAssign>::mul_assign fn mul_assign(&mut self, other: $t) { *self *= other }
<u16 as core::ops::arith::Rem<&u16>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::arith::Rem>::rem fn rem(self, other: $t) -> $t { self % other }
<u16 as core::ops::arith::RemAssign<&u16>>::rem_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::arith::RemAssign>::rem_assign fn rem_assign(&mut self, other: $t) { *self %= other }
<u16 as core::ops::arith::Sub<&u16>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::arith::Sub>::sub fn sub(self, other: $t) -> $t { self - other }
<u16 as core::ops::arith::SubAssign<&u16>>::sub_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::arith::SubAssign>::sub_assign fn sub_assign(&mut self, other: $t) { *self -= other }
<u16 as core::ops::bit::BitAnd<&u16>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::BitAnd>::bitand fn bitand(self, rhs: $t) -> $t { self & rhs }
<u16 as core::ops::bit::BitAndAssign<&u16>>::bitand_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::BitAndAssign>::bitand_assign fn bitand_assign(&mut self, other: $t) { *self &= other }
<u16 as core::ops::bit::BitOr<&u16>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::BitOr>::bitor fn bitor(self, rhs: $t) -> $t { self | rhs }
<u16 as core::ops::bit::BitOrAssign<&u16>>::bitor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::BitOrAssign>::bitor_assign fn bitor_assign(&mut self, other: $t) { *self |= other }
<u16 as core::ops::bit::BitXor<&u16>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::BitXor>::bitxor fn bitxor(self, other: $t) -> $t { self ^ other }
<u16 as core::ops::bit::BitXorAssign<&u16>>::bitxor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::BitXorAssign>::bitxor_assign fn bitxor_assign(&mut self, other: $t) { *self ^= other }
<u16 as core::ops::bit::Not>::not fn not(self) -> $t { !self }
<u16 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shl<i128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u16 as core::ops::bit::Shl<i16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u16 as core::ops::bit::Shl<i32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u16 as core::ops::bit::Shl<i64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u16 as core::ops::bit::Shl<i8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u16 as core::ops::bit::Shl<isize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u16 as core::ops::bit::Shl<u128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u16 as core::ops::bit::Shl<u32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u16 as core::ops::bit::Shl<u64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u16 as core::ops::bit::Shl<u8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u16 as core::ops::bit::Shl<usize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u16 as core::ops::bit::Shl>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u16 as core::ops::bit::ShlAssign<&i128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShlAssign<&i16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShlAssign<&i32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShlAssign<&i64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShlAssign<&i8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShlAssign<&isize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShlAssign<&u128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShlAssign<&u16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShlAssign<&u32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShlAssign<&u64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShlAssign<&u8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShlAssign<&usize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShlAssign<i128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u16 as core::ops::bit::ShlAssign<i16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u16 as core::ops::bit::ShlAssign<i32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u16 as core::ops::bit::ShlAssign<i64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u16 as core::ops::bit::ShlAssign<i8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u16 as core::ops::bit::ShlAssign<isize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u16 as core::ops::bit::ShlAssign<u128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u16 as core::ops::bit::ShlAssign<u32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u16 as core::ops::bit::ShlAssign<u64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u16 as core::ops::bit::ShlAssign<u8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u16 as core::ops::bit::ShlAssign<usize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u16 as core::ops::bit::ShlAssign>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u16 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u16 as core::ops::bit::Shr<i128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u16 as core::ops::bit::Shr<i16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u16 as core::ops::bit::Shr<i32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u16 as core::ops::bit::Shr<i64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u16 as core::ops::bit::Shr<i8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u16 as core::ops::bit::Shr<isize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u16 as core::ops::bit::Shr<u128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u16 as core::ops::bit::Shr<u32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u16 as core::ops::bit::Shr<u64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u16 as core::ops::bit::Shr<u8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u16 as core::ops::bit::Shr<usize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u16 as core::ops::bit::Shr>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u16 as core::ops::bit::ShrAssign<&i128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShrAssign<&i16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShrAssign<&i32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShrAssign<&i64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShrAssign<&i8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShrAssign<&isize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShrAssign<&u128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShrAssign<&u16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShrAssign<&u32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShrAssign<&u64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShrAssign<&u8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShrAssign<&usize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u16 as core::ops::bit::ShrAssign<i128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u16 as core::ops::bit::ShrAssign<i16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u16 as core::ops::bit::ShrAssign<i32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u16 as core::ops::bit::ShrAssign<i64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u16 as core::ops::bit::ShrAssign<i8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u16 as core::ops::bit::ShrAssign<isize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u16 as core::ops::bit::ShrAssign<u128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u16 as core::ops::bit::ShrAssign<u32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u16 as core::ops::bit::ShrAssign<u64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u16 as core::ops::bit::ShrAssign<u8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u16 as core::ops::bit::ShrAssign<usize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u16 as core::ops::bit::ShrAssign>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u32 as core::default::Default>::default fn default() -> $t {
$v
}
<u32 as core::ops::arith::Add<&u32>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::arith::Add>::add fn add(self, other: $t) -> $t { self + other }
<u32 as core::ops::arith::AddAssign<&u32>>::add_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::arith::AddAssign>::add_assign fn add_assign(&mut self, other: $t) { *self += other }
<u32 as core::ops::arith::Div<&u32>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::arith::Div>::div fn div(self, other: $t) -> $t { self / other }
<u32 as core::ops::arith::DivAssign<&u32>>::div_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::arith::DivAssign>::div_assign fn div_assign(&mut self, other: $t) { *self /= other }
<u32 as core::ops::arith::Mul<&u32>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::arith::Mul>::mul fn mul(self, other: $t) -> $t { self * other }
<u32 as core::ops::arith::MulAssign<&u32>>::mul_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::arith::MulAssign>::mul_assign fn mul_assign(&mut self, other: $t) { *self *= other }
<u32 as core::ops::arith::Rem<&u32>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::arith::Rem>::rem fn rem(self, other: $t) -> $t { self % other }
<u32 as core::ops::arith::RemAssign<&u32>>::rem_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::arith::RemAssign>::rem_assign fn rem_assign(&mut self, other: $t) { *self %= other }
<u32 as core::ops::arith::Sub<&u32>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::arith::Sub>::sub fn sub(self, other: $t) -> $t { self - other }
<u32 as core::ops::arith::SubAssign<&u32>>::sub_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::arith::SubAssign>::sub_assign fn sub_assign(&mut self, other: $t) { *self -= other }
<u32 as core::ops::bit::BitAnd<&u32>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::BitAnd>::bitand fn bitand(self, rhs: $t) -> $t { self & rhs }
<u32 as core::ops::bit::BitAndAssign<&u32>>::bitand_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::BitAndAssign>::bitand_assign fn bitand_assign(&mut self, other: $t) { *self &= other }
<u32 as core::ops::bit::BitOr<&u32>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::BitOr>::bitor fn bitor(self, rhs: $t) -> $t { self | rhs }
<u32 as core::ops::bit::BitOrAssign<&u32>>::bitor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::BitOrAssign>::bitor_assign fn bitor_assign(&mut self, other: $t) { *self |= other }
<u32 as core::ops::bit::BitXor<&u32>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::BitXor>::bitxor fn bitxor(self, other: $t) -> $t { self ^ other }
<u32 as core::ops::bit::BitXorAssign<&u32>>::bitxor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::BitXorAssign>::bitxor_assign fn bitxor_assign(&mut self, other: $t) { *self ^= other }
<u32 as core::ops::bit::Not>::not fn not(self) -> $t { !self }
<u32 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shl<i128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u32 as core::ops::bit::Shl<i16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u32 as core::ops::bit::Shl<i32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u32 as core::ops::bit::Shl<i64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u32 as core::ops::bit::Shl<i8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u32 as core::ops::bit::Shl<isize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u32 as core::ops::bit::Shl<u128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u32 as core::ops::bit::Shl<u16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u32 as core::ops::bit::Shl<u64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u32 as core::ops::bit::Shl<u8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u32 as core::ops::bit::Shl<usize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u32 as core::ops::bit::Shl>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u32 as core::ops::bit::ShlAssign<&i128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShlAssign<&i16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShlAssign<&i32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShlAssign<&i64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShlAssign<&i8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShlAssign<&isize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShlAssign<&u128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShlAssign<&u16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShlAssign<&u32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShlAssign<&u64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShlAssign<&u8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShlAssign<&usize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShlAssign<i128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u32 as core::ops::bit::ShlAssign<i16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u32 as core::ops::bit::ShlAssign<i32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u32 as core::ops::bit::ShlAssign<i64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u32 as core::ops::bit::ShlAssign<i8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u32 as core::ops::bit::ShlAssign<isize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u32 as core::ops::bit::ShlAssign<u128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u32 as core::ops::bit::ShlAssign<u16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u32 as core::ops::bit::ShlAssign<u64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u32 as core::ops::bit::ShlAssign<u8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u32 as core::ops::bit::ShlAssign<usize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u32 as core::ops::bit::ShlAssign>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u32 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u32 as core::ops::bit::Shr<i128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u32 as core::ops::bit::Shr<i16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u32 as core::ops::bit::Shr<i32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u32 as core::ops::bit::Shr<i64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u32 as core::ops::bit::Shr<i8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u32 as core::ops::bit::Shr<isize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u32 as core::ops::bit::Shr<u128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u32 as core::ops::bit::Shr<u16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u32 as core::ops::bit::Shr<u64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u32 as core::ops::bit::Shr<u8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u32 as core::ops::bit::Shr<usize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u32 as core::ops::bit::Shr>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u32 as core::ops::bit::ShrAssign<&i128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShrAssign<&i16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShrAssign<&i32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShrAssign<&i64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShrAssign<&i8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShrAssign<&isize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShrAssign<&u128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShrAssign<&u16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShrAssign<&u32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShrAssign<&u64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShrAssign<&u8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShrAssign<&usize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u32 as core::ops::bit::ShrAssign<i128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u32 as core::ops::bit::ShrAssign<i16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u32 as core::ops::bit::ShrAssign<i32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u32 as core::ops::bit::ShrAssign<i64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u32 as core::ops::bit::ShrAssign<i8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u32 as core::ops::bit::ShrAssign<isize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u32 as core::ops::bit::ShrAssign<u128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u32 as core::ops::bit::ShrAssign<u16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u32 as core::ops::bit::ShrAssign<u64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u32 as core::ops::bit::ShrAssign<u8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u32 as core::ops::bit::ShrAssign<usize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u32 as core::ops::bit::ShrAssign>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u64 as core::ops::arith::Add<&u64>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::arith::Add>::add fn add(self, other: $t) -> $t { self + other }
<u64 as core::ops::arith::AddAssign<&u64>>::add_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::arith::AddAssign>::add_assign fn add_assign(&mut self, other: $t) { *self += other }
<u64 as core::ops::arith::Div<&u64>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::arith::Div>::div fn div(self, other: $t) -> $t { self / other }
<u64 as core::ops::arith::DivAssign<&u64>>::div_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::arith::DivAssign>::div_assign fn div_assign(&mut self, other: $t) { *self /= other }
<u64 as core::ops::arith::Mul<&u64>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::arith::Mul>::mul fn mul(self, other: $t) -> $t { self * other }
<u64 as core::ops::arith::MulAssign<&u64>>::mul_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::arith::MulAssign>::mul_assign fn mul_assign(&mut self, other: $t) { *self *= other }
<u64 as core::ops::arith::Rem<&u64>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::arith::Rem>::rem fn rem(self, other: $t) -> $t { self % other }
<u64 as core::ops::arith::RemAssign<&u64>>::rem_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::arith::RemAssign>::rem_assign fn rem_assign(&mut self, other: $t) { *self %= other }
<u64 as core::ops::arith::Sub<&u64>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::arith::Sub>::sub fn sub(self, other: $t) -> $t { self - other }
<u64 as core::ops::arith::SubAssign<&u64>>::sub_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::arith::SubAssign>::sub_assign fn sub_assign(&mut self, other: $t) { *self -= other }
<u64 as core::ops::bit::BitAnd<&u64>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::BitAnd>::bitand fn bitand(self, rhs: $t) -> $t { self & rhs }
<u64 as core::ops::bit::BitAndAssign<&u64>>::bitand_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::BitAndAssign>::bitand_assign fn bitand_assign(&mut self, other: $t) { *self &= other }
<u64 as core::ops::bit::BitOr<&u64>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::BitOr>::bitor fn bitor(self, rhs: $t) -> $t { self | rhs }
<u64 as core::ops::bit::BitOrAssign<&u64>>::bitor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::BitOrAssign>::bitor_assign fn bitor_assign(&mut self, other: $t) { *self |= other }
<u64 as core::ops::bit::BitXor<&u64>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::BitXor>::bitxor fn bitxor(self, other: $t) -> $t { self ^ other }
<u64 as core::ops::bit::BitXorAssign<&u64>>::bitxor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::BitXorAssign>::bitxor_assign fn bitxor_assign(&mut self, other: $t) { *self ^= other }
<u64 as core::ops::bit::Not>::not fn not(self) -> $t { !self }
<u64 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shl<i128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u64 as core::ops::bit::Shl<i16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u64 as core::ops::bit::Shl<i32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u64 as core::ops::bit::Shl<i64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u64 as core::ops::bit::Shl<i8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u64 as core::ops::bit::Shl<isize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u64 as core::ops::bit::Shl<u128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u64 as core::ops::bit::Shl<u16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u64 as core::ops::bit::Shl<u32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u64 as core::ops::bit::Shl<u8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u64 as core::ops::bit::Shl<usize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u64 as core::ops::bit::Shl>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u64 as core::ops::bit::ShlAssign<&i128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShlAssign<&i16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShlAssign<&i32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShlAssign<&i64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShlAssign<&i8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShlAssign<&isize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShlAssign<&u128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShlAssign<&u16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShlAssign<&u32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShlAssign<&u64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShlAssign<&u8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShlAssign<&usize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShlAssign<i128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u64 as core::ops::bit::ShlAssign<i16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u64 as core::ops::bit::ShlAssign<i32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u64 as core::ops::bit::ShlAssign<i64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u64 as core::ops::bit::ShlAssign<i8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u64 as core::ops::bit::ShlAssign<isize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u64 as core::ops::bit::ShlAssign<u128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u64 as core::ops::bit::ShlAssign<u16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u64 as core::ops::bit::ShlAssign<u32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u64 as core::ops::bit::ShlAssign<u8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u64 as core::ops::bit::ShlAssign<usize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u64 as core::ops::bit::ShlAssign>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u64 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u64 as core::ops::bit::Shr<i128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u64 as core::ops::bit::Shr<i16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u64 as core::ops::bit::Shr<i32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u64 as core::ops::bit::Shr<i64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u64 as core::ops::bit::Shr<i8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u64 as core::ops::bit::Shr<isize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u64 as core::ops::bit::Shr<u128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u64 as core::ops::bit::Shr<u16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u64 as core::ops::bit::Shr<u32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u64 as core::ops::bit::Shr<u8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u64 as core::ops::bit::Shr<usize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u64 as core::ops::bit::Shr>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u64 as core::ops::bit::ShrAssign<&i128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShrAssign<&i16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShrAssign<&i32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShrAssign<&i64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShrAssign<&i8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShrAssign<&isize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShrAssign<&u128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShrAssign<&u16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShrAssign<&u32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShrAssign<&u64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShrAssign<&u8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShrAssign<&usize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u64 as core::ops::bit::ShrAssign<i128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u64 as core::ops::bit::ShrAssign<i16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u64 as core::ops::bit::ShrAssign<i32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u64 as core::ops::bit::ShrAssign<i64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u64 as core::ops::bit::ShrAssign<i8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u64 as core::ops::bit::ShrAssign<isize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u64 as core::ops::bit::ShrAssign<u128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u64 as core::ops::bit::ShrAssign<u16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u64 as core::ops::bit::ShrAssign<u32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u64 as core::ops::bit::ShrAssign<u8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u64 as core::ops::bit::ShrAssign<usize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u64 as core::ops::bit::ShrAssign>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u8 as core::ops::arith::Add<&u8>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::arith::Add>::add fn add(self, other: $t) -> $t { self + other }
<u8 as core::ops::arith::AddAssign<&u8>>::add_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::arith::AddAssign>::add_assign fn add_assign(&mut self, other: $t) { *self += other }
<u8 as core::ops::arith::Div<&u8>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::arith::Div>::div fn div(self, other: $t) -> $t { self / other }
<u8 as core::ops::arith::DivAssign<&u8>>::div_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::arith::DivAssign>::div_assign fn div_assign(&mut self, other: $t) { *self /= other }
<u8 as core::ops::arith::Mul<&u8>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::arith::Mul>::mul fn mul(self, other: $t) -> $t { self * other }
<u8 as core::ops::arith::MulAssign<&u8>>::mul_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::arith::MulAssign>::mul_assign fn mul_assign(&mut self, other: $t) { *self *= other }
<u8 as core::ops::arith::Rem<&u8>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::arith::Rem>::rem fn rem(self, other: $t) -> $t { self % other }
<u8 as core::ops::arith::RemAssign<&u8>>::rem_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::arith::RemAssign>::rem_assign fn rem_assign(&mut self, other: $t) { *self %= other }
<u8 as core::ops::arith::Sub<&u8>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::arith::Sub>::sub fn sub(self, other: $t) -> $t { self - other }
<u8 as core::ops::arith::SubAssign<&u8>>::sub_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::arith::SubAssign>::sub_assign fn sub_assign(&mut self, other: $t) { *self -= other }
<u8 as core::ops::bit::BitAnd<&u8>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::BitAnd>::bitand fn bitand(self, rhs: $t) -> $t { self & rhs }
<u8 as core::ops::bit::BitAndAssign<&u8>>::bitand_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::BitAndAssign>::bitand_assign fn bitand_assign(&mut self, other: $t) { *self &= other }
<u8 as core::ops::bit::BitOr<&u8>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::BitOr>::bitor fn bitor(self, rhs: $t) -> $t { self | rhs }
<u8 as core::ops::bit::BitOrAssign<&u8>>::bitor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::BitOrAssign>::bitor_assign fn bitor_assign(&mut self, other: $t) { *self |= other }
<u8 as core::ops::bit::BitXor<&u8>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::BitXor>::bitxor fn bitxor(self, other: $t) -> $t { self ^ other }
<u8 as core::ops::bit::BitXorAssign<&u8>>::bitxor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::BitXorAssign>::bitxor_assign fn bitxor_assign(&mut self, other: $t) { *self ^= other }
<u8 as core::ops::bit::Not>::not fn not(self) -> $t { !self }
<u8 as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shl<i128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u8 as core::ops::bit::Shl<i16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u8 as core::ops::bit::Shl<i32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u8 as core::ops::bit::Shl<i64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u8 as core::ops::bit::Shl<i8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u8 as core::ops::bit::Shl<isize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u8 as core::ops::bit::Shl<u128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u8 as core::ops::bit::Shl<u16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u8 as core::ops::bit::Shl<u32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u8 as core::ops::bit::Shl<u64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u8 as core::ops::bit::Shl<usize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u8 as core::ops::bit::Shl>::shl fn shl(self, other: $f) -> $t {
self << other
}
<u8 as core::ops::bit::ShlAssign<&i128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShlAssign<&i16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShlAssign<&i32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShlAssign<&i64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShlAssign<&i8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShlAssign<&isize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShlAssign<&u128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShlAssign<&u16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShlAssign<&u32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShlAssign<&u64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShlAssign<&u8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShlAssign<&usize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShlAssign<i128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u8 as core::ops::bit::ShlAssign<i16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u8 as core::ops::bit::ShlAssign<i32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u8 as core::ops::bit::ShlAssign<i64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u8 as core::ops::bit::ShlAssign<i8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u8 as core::ops::bit::ShlAssign<isize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u8 as core::ops::bit::ShlAssign<u128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u8 as core::ops::bit::ShlAssign<u16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u8 as core::ops::bit::ShlAssign<u32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u8 as core::ops::bit::ShlAssign<u64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u8 as core::ops::bit::ShlAssign<usize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u8 as core::ops::bit::ShlAssign>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<u8 as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<u8 as core::ops::bit::Shr<i128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u8 as core::ops::bit::Shr<i16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u8 as core::ops::bit::Shr<i32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u8 as core::ops::bit::Shr<i64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u8 as core::ops::bit::Shr<i8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u8 as core::ops::bit::Shr<isize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u8 as core::ops::bit::Shr<u128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u8 as core::ops::bit::Shr<u16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u8 as core::ops::bit::Shr<u32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u8 as core::ops::bit::Shr<u64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u8 as core::ops::bit::Shr<usize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u8 as core::ops::bit::Shr>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<u8 as core::ops::bit::ShrAssign<&i128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShrAssign<&i16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShrAssign<&i32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShrAssign<&i64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShrAssign<&i8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShrAssign<&isize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShrAssign<&u128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShrAssign<&u16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShrAssign<&u32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShrAssign<&u64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShrAssign<&u8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShrAssign<&usize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<u8 as core::ops::bit::ShrAssign<i128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u8 as core::ops::bit::ShrAssign<i16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u8 as core::ops::bit::ShrAssign<i32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u8 as core::ops::bit::ShrAssign<i64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u8 as core::ops::bit::ShrAssign<i8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u8 as core::ops::bit::ShrAssign<isize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u8 as core::ops::bit::ShrAssign<u128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u8 as core::ops::bit::ShrAssign<u16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u8 as core::ops::bit::ShrAssign<u32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u8 as core::ops::bit::ShrAssign<u64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u8 as core::ops::bit::ShrAssign<usize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<u8 as core::ops::bit::ShrAssign>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<usize as core::ops::arith::Add<&usize>>::add fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::arith::Add>::add fn add(self, other: $t) -> $t { self + other }
<usize as core::ops::arith::AddAssign<&usize>>::add_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::arith::AddAssign>::add_assign fn add_assign(&mut self, other: $t) { *self += other }
<usize as core::ops::arith::Div<&usize>>::div fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::arith::Div>::div fn div(self, other: $t) -> $t { self / other }
<usize as core::ops::arith::DivAssign<&usize>>::div_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::arith::DivAssign>::div_assign fn div_assign(&mut self, other: $t) { *self /= other }
<usize as core::ops::arith::Mul<&usize>>::mul fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::arith::Mul>::mul fn mul(self, other: $t) -> $t { self * other }
<usize as core::ops::arith::MulAssign<&usize>>::mul_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::arith::MulAssign>::mul_assign fn mul_assign(&mut self, other: $t) { *self *= other }
<usize as core::ops::arith::Rem<&usize>>::rem fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::arith::Rem>::rem fn rem(self, other: $t) -> $t { self % other }
<usize as core::ops::arith::RemAssign<&usize>>::rem_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::arith::RemAssign>::rem_assign fn rem_assign(&mut self, other: $t) { *self %= other }
<usize as core::ops::arith::Sub<&usize>>::sub fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::arith::Sub>::sub fn sub(self, other: $t) -> $t { self - other }
<usize as core::ops::arith::SubAssign<&usize>>::sub_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::arith::SubAssign>::sub_assign fn sub_assign(&mut self, other: $t) { *self -= other }
<usize as core::ops::bit::BitAnd<&usize>>::bitand fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::BitAnd>::bitand fn bitand(self, rhs: $t) -> $t { self & rhs }
<usize as core::ops::bit::BitAndAssign<&usize>>::bitand_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::BitAndAssign>::bitand_assign fn bitand_assign(&mut self, other: $t) { *self &= other }
<usize as core::ops::bit::BitOr<&usize>>::bitor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::BitOr>::bitor fn bitor(self, rhs: $t) -> $t { self | rhs }
<usize as core::ops::bit::BitOrAssign<&usize>>::bitor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::BitOrAssign>::bitor_assign fn bitor_assign(&mut self, other: $t) { *self |= other }
<usize as core::ops::bit::BitXor<&usize>>::bitxor fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::BitXor>::bitxor fn bitxor(self, other: $t) -> $t { self ^ other }
<usize as core::ops::bit::BitXorAssign<&usize>>::bitxor_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::BitXorAssign>::bitxor_assign fn bitxor_assign(&mut self, other: $t) { *self ^= other }
<usize as core::ops::bit::Not>::not fn not(self) -> $t { !self }
<usize as core::ops::bit::Shl<&i128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shl<&i16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shl<&i32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shl<&i64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shl<&i8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shl<&isize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shl<&u128>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shl<&u16>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shl<&u32>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shl<&u64>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shl<&u8>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shl<&usize>>::shl fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shl<i128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<usize as core::ops::bit::Shl<i16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<usize as core::ops::bit::Shl<i32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<usize as core::ops::bit::Shl<i64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<usize as core::ops::bit::Shl<i8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<usize as core::ops::bit::Shl<isize>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<usize as core::ops::bit::Shl<u128>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<usize as core::ops::bit::Shl<u16>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<usize as core::ops::bit::Shl<u32>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<usize as core::ops::bit::Shl<u64>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<usize as core::ops::bit::Shl<u8>>::shl fn shl(self, other: $f) -> $t {
self << other
}
<usize as core::ops::bit::Shl>::shl fn shl(self, other: $f) -> $t {
self << other
}
<usize as core::ops::bit::ShlAssign<&i128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShlAssign<&i16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShlAssign<&i32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShlAssign<&i64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShlAssign<&i8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShlAssign<&isize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShlAssign<&u128>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShlAssign<&u16>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShlAssign<&u32>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShlAssign<&u64>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShlAssign<&u8>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShlAssign<&usize>>::shl_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShlAssign<i128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<usize as core::ops::bit::ShlAssign<i16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<usize as core::ops::bit::ShlAssign<i32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<usize as core::ops::bit::ShlAssign<i64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<usize as core::ops::bit::ShlAssign<i8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<usize as core::ops::bit::ShlAssign<isize>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<usize as core::ops::bit::ShlAssign<u128>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<usize as core::ops::bit::ShlAssign<u16>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<usize as core::ops::bit::ShlAssign<u32>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<usize as core::ops::bit::ShlAssign<u64>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<usize as core::ops::bit::ShlAssign<u8>>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<usize as core::ops::bit::ShlAssign>::shl_assign fn shl_assign(&mut self, other: $f) {
*self <<= other
}
<usize as core::ops::bit::Shr<&i128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shr<&i16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shr<&i32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shr<&i64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shr<&i8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shr<&isize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shr<&u128>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shr<&u16>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shr<&u32>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shr<&u64>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shr<&u8>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shr<&usize>>::shr fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
$imp::$method(self, *other)
}
<usize as core::ops::bit::Shr<i128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<usize as core::ops::bit::Shr<i16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<usize as core::ops::bit::Shr<i32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<usize as core::ops::bit::Shr<i64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<usize as core::ops::bit::Shr<i8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<usize as core::ops::bit::Shr<isize>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<usize as core::ops::bit::Shr<u128>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<usize as core::ops::bit::Shr<u16>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<usize as core::ops::bit::Shr<u32>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<usize as core::ops::bit::Shr<u64>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<usize as core::ops::bit::Shr<u8>>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<usize as core::ops::bit::Shr>::shr fn shr(self, other: $f) -> $t {
self >> other
}
<usize as core::ops::bit::ShrAssign<&i128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShrAssign<&i16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShrAssign<&i32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShrAssign<&i64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShrAssign<&i8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShrAssign<&isize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShrAssign<&u128>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShrAssign<&u16>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShrAssign<&u32>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShrAssign<&u64>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShrAssign<&u8>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShrAssign<&usize>>::shr_assign fn $method(&mut self, other: &$u) {
$imp::$method(self, *other);
}
<usize as core::ops::bit::ShrAssign<i128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<usize as core::ops::bit::ShrAssign<i16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<usize as core::ops::bit::ShrAssign<i32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<usize as core::ops::bit::ShrAssign<i64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<usize as core::ops::bit::ShrAssign<i8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<usize as core::ops::bit::ShrAssign<isize>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<usize as core::ops::bit::ShrAssign<u128>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<usize as core::ops::bit::ShrAssign<u16>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<usize as core::ops::bit::ShrAssign<u32>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<usize as core::ops::bit::ShrAssign<u64>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<usize as core::ops::bit::ShrAssign<u8>>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
<usize as core::ops::bit::ShrAssign>::shr_assign fn shr_assign(&mut self, other: $f) {
*self >>= other
}
core::alloc::layout::Layout::align pub const fn align(&self) -> usize {
self.align.as_usize()
}
core::alloc::layout::Layout::from_size_align_unchecked pub const unsafe fn from_size_align_unchecked(size: usize, align: usize) -> Self {
assert_unsafe_precondition!(
check_library_ub,
"Layout::from_size_align_unchecked requires that align is a power of 2 \
and the rounded-up allocation size does not exceed isize::MAX",
(
size: usize = size,
align: usize = align,
) => Layout::is_size_align_valid(size, align)
);
// SAFETY: the caller is required to uphold the preconditions.
unsafe { Layout { size, align: mem::transmute(align) } }
}
core::alloc::layout::Layout::max_size_for_align const fn max_size_for_align(align: Alignment) -> usize {
// (power-of-two implies align != 0.)
// Rounded up size is:
// size_rounded_up = (size + align - 1) & !(align - 1);
//
// We know from above that align != 0. If adding (align - 1)
// does not overflow, then rounding up will be fine.
//
// Conversely, &-masking with !(align - 1) will subtract off
// only low-order-bits. Thus if overflow occurs with the sum,
// the &-mask cannot subtract enough to undo that overflow.
//
// Above implies that checking for summation overflow is both
// necessary and sufficient.
// SAFETY: the maximum possible alignment is `isize::MAX + 1`,
// so the subtraction cannot overflow.
unsafe { unchecked_sub(isize::MAX as usize + 1, align.as_usize()) }
}
core::alloc::layout::Layout::new pub const fn new<T>() -> Self {
let (size, align) = size_align::<T>();
// SAFETY: if the type is instantiated, rustc already ensures that its
// layout is valid. Use the unchecked constructor to avoid inserting a
// panicking codepath that needs to be optimized out.
unsafe { Layout::from_size_align_unchecked(size, align) }
}
core::alloc::layout::Layout::size pub const fn size(&self) -> usize {
self.size
}
core::alloc::layout::size_alignconst fn size_align<T>() -> (usize, usize) {
(size_of::<T>(), align_of::<T>())
}
core::array::<impl [T; N]>::as_mut_slice pub const fn as_mut_slice(&mut self) -> &mut [T] {
self
}
core::array::<impl [T; N]>::as_slice pub const fn as_slice(&self) -> &[T] {
self
}
core::bool::<impl bool>::ok_or pub fn ok_or<E>(self, err: E) -> Result<(), E> {
if self { Ok(()) } else { Err(err) }
}
core::bool::<impl bool>::ok_or_else pub fn ok_or_else<E, F: FnOnce() -> E>(self, f: F) -> Result<(), E> {
if self { Ok(()) } else { Err(f()) }
}
core::bool::<impl bool>::then pub fn then<T, F: FnOnce() -> T>(self, f: F) -> Option<T> {
if self { Some(f()) } else { None }
}
core::bool::<impl bool>::then_some pub fn then_some<T>(self, t: T) -> Option<T> {
if self { Some(t) } else { None }
}
core::cell::UnsafeCell::<T>::get pub const fn get(&self) -> *mut T {
// We can just cast the pointer from `UnsafeCell<T>` to `T` because of
// #[repr(transparent)]. This exploits std's special status, there is
// no guarantee for user code that this will work in future versions of the compiler!
self as *const UnsafeCell<T> as *const T as *mut T
}
core::cell::UnsafeCell::<T>::get_mut pub const fn get_mut(&mut self) -> &mut T {
&mut self.value
}
core::cell::UnsafeCell::<T>::into_inner pub const fn into_inner(self) -> T {
self.value
}
core::cell::UnsafeCell::<T>::new pub const fn new(value: T) -> UnsafeCell<T> {
UnsafeCell { value }
}
core::clone::Clone::clone_from fn clone_from(&mut self, source: &Self)
where
Self: [const] Destruct,
{
*self = source.clone()
}
core::clone::impls::<impl core::clone::Clone for &T>::clone fn clone(&self) -> Self {
self
}
core::clone::impls::<impl core::clone::Clone for bool>::clone fn clone(&self) -> Self {
*self
}
core::clone::impls::<impl core::clone::Clone for f32>::clone fn clone(&self) -> Self {
*self
}
core::clone::impls::<impl core::clone::Clone for f64>::clone fn clone(&self) -> Self {
*self
}
core::clone::impls::<impl core::clone::Clone for i128>::clone fn clone(&self) -> Self {
*self
}
core::clone::impls::<impl core::clone::Clone for i16>::clone fn clone(&self) -> Self {
*self
}
core::clone::impls::<impl core::clone::Clone for i32>::clone fn clone(&self) -> Self {
*self
}
core::clone::impls::<impl core::clone::Clone for i64>::clone fn clone(&self) -> Self {
*self
}
core::clone::impls::<impl core::clone::Clone for i8>::clone fn clone(&self) -> Self {
*self
}
core::clone::impls::<impl core::clone::Clone for isize>::clone fn clone(&self) -> Self {
*self
}
core::clone::impls::<impl core::clone::Clone for u128>::clone fn clone(&self) -> Self {
*self
}
core::clone::impls::<impl core::clone::Clone for u16>::clone fn clone(&self) -> Self {
*self
}
core::clone::impls::<impl core::clone::Clone for u32>::clone fn clone(&self) -> Self {
*self
}
core::clone::impls::<impl core::clone::Clone for u64>::clone fn clone(&self) -> Self {
*self
}
core::clone::impls::<impl core::clone::Clone for u8>::clone fn clone(&self) -> Self {
*self
}
core::clone::impls::<impl core::clone::Clone for usize>::clone fn clone(&self) -> Self {
*self
}
core::cmp::Ord::clamp fn clamp(self, min: Self, max: Self) -> Self
where
Self: Sized + [const] Destruct,
{
assert!(min <= max);
if self < min {
min
} else if self > max {
max
} else {
self
}
}
core::cmp::Ord::max fn max(self, other: Self) -> Self
where
Self: Sized + [const] Destruct,
{
if other < self { self } else { other }
}
core::cmp::Ord::min fn min(self, other: Self) -> Self
where
Self: Sized + [const] Destruct,
{
if other < self { other } else { self }
}
core::cmp::Ordering::as_raw const fn as_raw(self) -> i8 {
// FIXME(const-hack): just use `PartialOrd` against `Equal` once that's const
crate::intrinsics::discriminant_value(&self)
}
core::cmp::Ordering::is_eq pub const fn is_eq(self) -> bool {
// All the `is_*` methods are implemented as comparisons against zero
// to follow how clang's libcxx implements their equivalents in
// <https://github.com/llvm/llvm-project/blob/60486292b79885b7800b082754153202bef5b1f0/libcxx/include/__compare/is_eq.h#L23-L28>
self.as_raw() == 0
}
core::cmp::Ordering::is_ge pub const fn is_ge(self) -> bool {
self.as_raw() >= 0
}
core::cmp::Ordering::is_gt pub const fn is_gt(self) -> bool {
self.as_raw() > 0
}
core::cmp::Ordering::is_le pub const fn is_le(self) -> bool {
self.as_raw() <= 0
}
core::cmp::Ordering::is_lt pub const fn is_lt(self) -> bool {
self.as_raw() < 0
}
core::cmp::Ordering::is_ne pub const fn is_ne(self) -> bool {
self.as_raw() != 0
}
core::cmp::Ordering::reverse pub const fn reverse(self) -> Ordering {
match self {
Less => Greater,
Equal => Equal,
Greater => Less,
}
}
core::cmp::Ordering::then pub const fn then(self, other: Ordering) -> Ordering {
match self {
Equal => other,
_ => self,
}
}
core::cmp::PartialEq::ne fn ne(&self, other: &Rhs) -> bool {
!self.eq(other)
}
core::cmp::PartialOrd::__chaining_ge fn __chaining_ge(&self, other: &Rhs) -> ControlFlow<bool> {
default_chaining_impl(self, other, Ordering::is_ge)
}
core::cmp::PartialOrd::__chaining_gt fn __chaining_gt(&self, other: &Rhs) -> ControlFlow<bool> {
default_chaining_impl(self, other, Ordering::is_gt)
}
core::cmp::PartialOrd::__chaining_le fn __chaining_le(&self, other: &Rhs) -> ControlFlow<bool> {
default_chaining_impl(self, other, Ordering::is_le)
}
core::cmp::PartialOrd::__chaining_lt fn __chaining_lt(&self, other: &Rhs) -> ControlFlow<bool> {
default_chaining_impl(self, other, Ordering::is_lt)
}
core::cmp::PartialOrd::ge fn ge(&self, other: &Rhs) -> bool {
self.partial_cmp(other).is_some_and(Ordering::is_ge)
}
core::cmp::PartialOrd::gt fn gt(&self, other: &Rhs) -> bool {
self.partial_cmp(other).is_some_and(Ordering::is_gt)
}
core::cmp::PartialOrd::le fn le(&self, other: &Rhs) -> bool {
self.partial_cmp(other).is_some_and(Ordering::is_le)
}
core::cmp::PartialOrd::lt fn lt(&self, other: &Rhs) -> bool {
self.partial_cmp(other).is_some_and(Ordering::is_lt)
}
core::cmp::impls::<impl core::cmp::Ord for bool>::clamp fn clamp(self, min: bool, max: bool) -> bool {
assert!(min <= max);
self.max(min).min(max)
}
core::cmp::impls::<impl core::cmp::Ord for bool>::max fn max(self, other: bool) -> bool {
self | other
}
core::cmp::impls::<impl core::cmp::Ord for bool>::min fn min(self, other: bool) -> bool {
self & other
}
core::cmp::impls::<impl core::cmp::Ord for i128>::cmp fn cmp(&self, other: &Self) -> Ordering {
crate::intrinsics::three_way_compare(*self, *other)
}
core::cmp::impls::<impl core::cmp::Ord for i16>::cmp fn cmp(&self, other: &Self) -> Ordering {
crate::intrinsics::three_way_compare(*self, *other)
}
core::cmp::impls::<impl core::cmp::Ord for i32>::cmp fn cmp(&self, other: &Self) -> Ordering {
crate::intrinsics::three_way_compare(*self, *other)
}
core::cmp::impls::<impl core::cmp::Ord for i64>::cmp fn cmp(&self, other: &Self) -> Ordering {
crate::intrinsics::three_way_compare(*self, *other)
}
core::cmp::impls::<impl core::cmp::Ord for i8>::cmp fn cmp(&self, other: &Self) -> Ordering {
crate::intrinsics::three_way_compare(*self, *other)
}
core::cmp::impls::<impl core::cmp::Ord for isize>::cmp fn cmp(&self, other: &Self) -> Ordering {
crate::intrinsics::three_way_compare(*self, *other)
}
core::cmp::impls::<impl core::cmp::Ord for u128>::cmp fn cmp(&self, other: &Self) -> Ordering {
crate::intrinsics::three_way_compare(*self, *other)
}
core::cmp::impls::<impl core::cmp::Ord for u16>::cmp fn cmp(&self, other: &Self) -> Ordering {
crate::intrinsics::three_way_compare(*self, *other)
}
core::cmp::impls::<impl core::cmp::Ord for u32>::cmp fn cmp(&self, other: &Self) -> Ordering {
crate::intrinsics::three_way_compare(*self, *other)
}
core::cmp::impls::<impl core::cmp::Ord for u64>::cmp fn cmp(&self, other: &Self) -> Ordering {
crate::intrinsics::three_way_compare(*self, *other)
}
core::cmp::impls::<impl core::cmp::Ord for u8>::cmp fn cmp(&self, other: &Self) -> Ordering {
crate::intrinsics::three_way_compare(*self, *other)
}
core::cmp::impls::<impl core::cmp::Ord for usize>::cmp fn cmp(&self, other: &Self) -> Ordering {
crate::intrinsics::three_way_compare(*self, *other)
}
core::cmp::impls::<impl core::cmp::PartialEq for bool>::eq fn eq(&self, other: &Self) -> bool { *self == *other }
core::cmp::impls::<impl core::cmp::PartialEq for bool>::ne fn ne(&self, other: &Self) -> bool { *self != *other }
core::cmp::impls::<impl core::cmp::PartialEq for f32>::eq fn eq(&self, other: &Self) -> bool { *self == *other }
core::cmp::impls::<impl core::cmp::PartialEq for f32>::ne fn ne(&self, other: &Self) -> bool { *self != *other }
core::cmp::impls::<impl core::cmp::PartialEq for f64>::eq fn eq(&self, other: &Self) -> bool { *self == *other }
core::cmp::impls::<impl core::cmp::PartialEq for f64>::ne fn ne(&self, other: &Self) -> bool { *self != *other }
core::cmp::impls::<impl core::cmp::PartialEq for i128>::eq fn eq(&self, other: &Self) -> bool { *self == *other }
core::cmp::impls::<impl core::cmp::PartialEq for i128>::ne fn ne(&self, other: &Self) -> bool { *self != *other }
core::cmp::impls::<impl core::cmp::PartialEq for i16>::eq fn eq(&self, other: &Self) -> bool { *self == *other }
core::cmp::impls::<impl core::cmp::PartialEq for i16>::ne fn ne(&self, other: &Self) -> bool { *self != *other }
core::cmp::impls::<impl core::cmp::PartialEq for i32>::eq fn eq(&self, other: &Self) -> bool { *self == *other }
core::cmp::impls::<impl core::cmp::PartialEq for i32>::ne fn ne(&self, other: &Self) -> bool { *self != *other }
core::cmp::impls::<impl core::cmp::PartialEq for i64>::eq fn eq(&self, other: &Self) -> bool { *self == *other }
core::cmp::impls::<impl core::cmp::PartialEq for i64>::ne fn ne(&self, other: &Self) -> bool { *self != *other }
core::cmp::impls::<impl core::cmp::PartialEq for i8>::eq fn eq(&self, other: &Self) -> bool { *self == *other }
core::cmp::impls::<impl core::cmp::PartialEq for i8>::ne fn ne(&self, other: &Self) -> bool { *self != *other }
core::cmp::impls::<impl core::cmp::PartialEq for isize>::eq fn eq(&self, other: &Self) -> bool { *self == *other }
core::cmp::impls::<impl core::cmp::PartialEq for isize>::ne fn ne(&self, other: &Self) -> bool { *self != *other }
core::cmp::impls::<impl core::cmp::PartialEq for u128>::eq fn eq(&self, other: &Self) -> bool { *self == *other }
core::cmp::impls::<impl core::cmp::PartialEq for u128>::ne fn ne(&self, other: &Self) -> bool { *self != *other }
core::cmp::impls::<impl core::cmp::PartialEq for u16>::eq fn eq(&self, other: &Self) -> bool { *self == *other }
core::cmp::impls::<impl core::cmp::PartialEq for u16>::ne fn ne(&self, other: &Self) -> bool { *self != *other }
core::cmp::impls::<impl core::cmp::PartialEq for u32>::eq fn eq(&self, other: &Self) -> bool { *self == *other }
core::cmp::impls::<impl core::cmp::PartialEq for u32>::ne fn ne(&self, other: &Self) -> bool { *self != *other }
core::cmp::impls::<impl core::cmp::PartialEq for u64>::eq fn eq(&self, other: &Self) -> bool { *self == *other }
core::cmp::impls::<impl core::cmp::PartialEq for u64>::ne fn ne(&self, other: &Self) -> bool { *self != *other }
core::cmp::impls::<impl core::cmp::PartialEq for u8>::eq fn eq(&self, other: &Self) -> bool { *self == *other }
core::cmp::impls::<impl core::cmp::PartialEq for u8>::ne fn ne(&self, other: &Self) -> bool { *self != *other }
core::cmp::impls::<impl core::cmp::PartialEq for usize>::eq fn eq(&self, other: &Self) -> bool { *self == *other }
core::cmp::impls::<impl core::cmp::PartialEq for usize>::ne fn ne(&self, other: &Self) -> bool { *self != *other }
core::cmp::impls::<impl core::cmp::PartialOrd for bool>::__chaining_ge fn __chaining_ge(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs >= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for bool>::__chaining_gt fn __chaining_gt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs > rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for bool>::__chaining_le fn __chaining_le(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs <= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for bool>::__chaining_lt fn __chaining_lt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs < rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for bool>::ge fn ge(&self, other: &Self) -> bool { *self >= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for bool>::gt fn gt(&self, other: &Self) -> bool { *self > *other }
core::cmp::impls::<impl core::cmp::PartialOrd for bool>::le fn le(&self, other: &Self) -> bool { *self <= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for bool>::lt fn lt(&self, other: &Self) -> bool { *self < *other }
core::cmp::impls::<impl core::cmp::PartialOrd for bool>::partial_cmp fn partial_cmp(&self, other: &bool) -> Option<Ordering> {
Some(self.cmp(other))
}
core::cmp::impls::<impl core::cmp::PartialOrd for f32>::__chaining_ge fn __chaining_ge(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs >= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for f32>::__chaining_gt fn __chaining_gt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs > rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for f32>::__chaining_le fn __chaining_le(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs <= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for f32>::__chaining_lt fn __chaining_lt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs < rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for f32>::ge fn ge(&self, other: &Self) -> bool { *self >= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for f32>::gt fn gt(&self, other: &Self) -> bool { *self > *other }
core::cmp::impls::<impl core::cmp::PartialOrd for f32>::le fn le(&self, other: &Self) -> bool { *self <= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for f32>::lt fn lt(&self, other: &Self) -> bool { *self < *other }
core::cmp::impls::<impl core::cmp::PartialOrd for f32>::partial_cmp fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
match (*self <= *other, *self >= *other) {
(false, false) => None,
(false, true) => Some(Greater),
(true, false) => Some(Less),
(true, true) => Some(Equal),
}
}
core::cmp::impls::<impl core::cmp::PartialOrd for f64>::__chaining_ge fn __chaining_ge(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs >= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for f64>::__chaining_gt fn __chaining_gt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs > rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for f64>::__chaining_le fn __chaining_le(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs <= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for f64>::__chaining_lt fn __chaining_lt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs < rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for f64>::ge fn ge(&self, other: &Self) -> bool { *self >= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for f64>::gt fn gt(&self, other: &Self) -> bool { *self > *other }
core::cmp::impls::<impl core::cmp::PartialOrd for f64>::le fn le(&self, other: &Self) -> bool { *self <= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for f64>::lt fn lt(&self, other: &Self) -> bool { *self < *other }
core::cmp::impls::<impl core::cmp::PartialOrd for f64>::partial_cmp fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
match (*self <= *other, *self >= *other) {
(false, false) => None,
(false, true) => Some(Greater),
(true, false) => Some(Less),
(true, true) => Some(Equal),
}
}
core::cmp::impls::<impl core::cmp::PartialOrd for i128>::__chaining_ge fn __chaining_ge(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs >= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i128>::__chaining_gt fn __chaining_gt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs > rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i128>::__chaining_le fn __chaining_le(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs <= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i128>::__chaining_lt fn __chaining_lt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs < rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i128>::ge fn ge(&self, other: &Self) -> bool { *self >= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i128>::gt fn gt(&self, other: &Self) -> bool { *self > *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i128>::le fn le(&self, other: &Self) -> bool { *self <= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i128>::lt fn lt(&self, other: &Self) -> bool { *self < *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i128>::partial_cmp fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(crate::intrinsics::three_way_compare(*self, *other))
}
core::cmp::impls::<impl core::cmp::PartialOrd for i16>::__chaining_ge fn __chaining_ge(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs >= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i16>::__chaining_gt fn __chaining_gt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs > rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i16>::__chaining_le fn __chaining_le(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs <= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i16>::__chaining_lt fn __chaining_lt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs < rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i16>::ge fn ge(&self, other: &Self) -> bool { *self >= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i16>::gt fn gt(&self, other: &Self) -> bool { *self > *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i16>::le fn le(&self, other: &Self) -> bool { *self <= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i16>::lt fn lt(&self, other: &Self) -> bool { *self < *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i16>::partial_cmp fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(crate::intrinsics::three_way_compare(*self, *other))
}
core::cmp::impls::<impl core::cmp::PartialOrd for i32>::__chaining_ge fn __chaining_ge(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs >= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i32>::__chaining_gt fn __chaining_gt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs > rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i32>::__chaining_le fn __chaining_le(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs <= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i32>::__chaining_lt fn __chaining_lt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs < rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i32>::ge fn ge(&self, other: &Self) -> bool { *self >= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i32>::gt fn gt(&self, other: &Self) -> bool { *self > *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i32>::le fn le(&self, other: &Self) -> bool { *self <= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i32>::lt fn lt(&self, other: &Self) -> bool { *self < *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i32>::partial_cmp fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(crate::intrinsics::three_way_compare(*self, *other))
}
core::cmp::impls::<impl core::cmp::PartialOrd for i64>::__chaining_ge fn __chaining_ge(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs >= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i64>::__chaining_gt fn __chaining_gt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs > rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i64>::__chaining_le fn __chaining_le(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs <= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i64>::__chaining_lt fn __chaining_lt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs < rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i64>::ge fn ge(&self, other: &Self) -> bool { *self >= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i64>::gt fn gt(&self, other: &Self) -> bool { *self > *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i64>::le fn le(&self, other: &Self) -> bool { *self <= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i64>::lt fn lt(&self, other: &Self) -> bool { *self < *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i64>::partial_cmp fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(crate::intrinsics::three_way_compare(*self, *other))
}
core::cmp::impls::<impl core::cmp::PartialOrd for i8>::__chaining_ge fn __chaining_ge(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs >= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i8>::__chaining_gt fn __chaining_gt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs > rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i8>::__chaining_le fn __chaining_le(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs <= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i8>::__chaining_lt fn __chaining_lt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs < rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for i8>::ge fn ge(&self, other: &Self) -> bool { *self >= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i8>::gt fn gt(&self, other: &Self) -> bool { *self > *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i8>::le fn le(&self, other: &Self) -> bool { *self <= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i8>::lt fn lt(&self, other: &Self) -> bool { *self < *other }
core::cmp::impls::<impl core::cmp::PartialOrd for i8>::partial_cmp fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(crate::intrinsics::three_way_compare(*self, *other))
}
core::cmp::impls::<impl core::cmp::PartialOrd for isize>::__chaining_ge fn __chaining_ge(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs >= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for isize>::__chaining_gt fn __chaining_gt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs > rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for isize>::__chaining_le fn __chaining_le(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs <= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for isize>::__chaining_lt fn __chaining_lt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs < rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for isize>::ge fn ge(&self, other: &Self) -> bool { *self >= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for isize>::gt fn gt(&self, other: &Self) -> bool { *self > *other }
core::cmp::impls::<impl core::cmp::PartialOrd for isize>::le fn le(&self, other: &Self) -> bool { *self <= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for isize>::lt fn lt(&self, other: &Self) -> bool { *self < *other }
core::cmp::impls::<impl core::cmp::PartialOrd for isize>::partial_cmp fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(crate::intrinsics::three_way_compare(*self, *other))
}
core::cmp::impls::<impl core::cmp::PartialOrd for u128>::__chaining_ge fn __chaining_ge(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs >= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u128>::__chaining_gt fn __chaining_gt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs > rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u128>::__chaining_le fn __chaining_le(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs <= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u128>::__chaining_lt fn __chaining_lt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs < rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u128>::ge fn ge(&self, other: &Self) -> bool { *self >= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u128>::gt fn gt(&self, other: &Self) -> bool { *self > *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u128>::le fn le(&self, other: &Self) -> bool { *self <= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u128>::lt fn lt(&self, other: &Self) -> bool { *self < *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u128>::partial_cmp fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(crate::intrinsics::three_way_compare(*self, *other))
}
core::cmp::impls::<impl core::cmp::PartialOrd for u16>::__chaining_ge fn __chaining_ge(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs >= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u16>::__chaining_gt fn __chaining_gt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs > rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u16>::__chaining_le fn __chaining_le(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs <= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u16>::__chaining_lt fn __chaining_lt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs < rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u16>::ge fn ge(&self, other: &Self) -> bool { *self >= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u16>::gt fn gt(&self, other: &Self) -> bool { *self > *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u16>::le fn le(&self, other: &Self) -> bool { *self <= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u16>::lt fn lt(&self, other: &Self) -> bool { *self < *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u16>::partial_cmp fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(crate::intrinsics::three_way_compare(*self, *other))
}
core::cmp::impls::<impl core::cmp::PartialOrd for u32>::__chaining_ge fn __chaining_ge(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs >= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u32>::__chaining_gt fn __chaining_gt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs > rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u32>::__chaining_le fn __chaining_le(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs <= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u32>::__chaining_lt fn __chaining_lt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs < rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u32>::ge fn ge(&self, other: &Self) -> bool { *self >= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u32>::gt fn gt(&self, other: &Self) -> bool { *self > *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u32>::le fn le(&self, other: &Self) -> bool { *self <= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u32>::lt fn lt(&self, other: &Self) -> bool { *self < *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u32>::partial_cmp fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(crate::intrinsics::three_way_compare(*self, *other))
}
core::cmp::impls::<impl core::cmp::PartialOrd for u64>::__chaining_ge fn __chaining_ge(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs >= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u64>::__chaining_gt fn __chaining_gt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs > rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u64>::__chaining_le fn __chaining_le(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs <= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u64>::__chaining_lt fn __chaining_lt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs < rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u64>::ge fn ge(&self, other: &Self) -> bool { *self >= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u64>::gt fn gt(&self, other: &Self) -> bool { *self > *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u64>::le fn le(&self, other: &Self) -> bool { *self <= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u64>::lt fn lt(&self, other: &Self) -> bool { *self < *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u64>::partial_cmp fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(crate::intrinsics::three_way_compare(*self, *other))
}
core::cmp::impls::<impl core::cmp::PartialOrd for u8>::__chaining_ge fn __chaining_ge(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs >= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u8>::__chaining_gt fn __chaining_gt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs > rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u8>::__chaining_le fn __chaining_le(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs <= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u8>::__chaining_lt fn __chaining_lt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs < rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for u8>::ge fn ge(&self, other: &Self) -> bool { *self >= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u8>::gt fn gt(&self, other: &Self) -> bool { *self > *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u8>::le fn le(&self, other: &Self) -> bool { *self <= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u8>::lt fn lt(&self, other: &Self) -> bool { *self < *other }
core::cmp::impls::<impl core::cmp::PartialOrd for u8>::partial_cmp fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(crate::intrinsics::three_way_compare(*self, *other))
}
core::cmp::impls::<impl core::cmp::PartialOrd for usize>::__chaining_ge fn __chaining_ge(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs >= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for usize>::__chaining_gt fn __chaining_gt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs > rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for usize>::__chaining_le fn __chaining_le(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs <= rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for usize>::__chaining_lt fn __chaining_lt(&self, other: &Self) -> ControlFlow<bool> {
let (lhs, rhs) = (*self, *other);
if lhs == rhs { Continue(()) } else { Break(lhs < rhs) }
}
core::cmp::impls::<impl core::cmp::PartialOrd for usize>::ge fn ge(&self, other: &Self) -> bool { *self >= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for usize>::gt fn gt(&self, other: &Self) -> bool { *self > *other }
core::cmp::impls::<impl core::cmp::PartialOrd for usize>::le fn le(&self, other: &Self) -> bool { *self <= *other }
core::cmp::impls::<impl core::cmp::PartialOrd for usize>::lt fn lt(&self, other: &Self) -> bool { *self < *other }
core::cmp::impls::<impl core::cmp::PartialOrd for usize>::partial_cmp fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(crate::intrinsics::three_way_compare(*self, *other))
}
core::cmp::maxpub const fn max<T: [const] Ord + [const] Destruct>(v1: T, v2: T) -> T {
v1.max(v2)
}
core::cmp::minpub const fn min<T: [const] Ord + [const] Destruct>(v1: T, v2: T) -> T {
v1.min(v2)
}
core::convert::identitypub const fn identity<T>(x: T) -> T {
x
}
core::intrinsics::ptr_guaranteed_cmppub const fn ptr_guaranteed_cmp<T>(ptr: *const T, other: *const T) -> u8 {
(ptr == other) as u8
}
core::mem::align_ofpub const fn align_of<T>() -> usize {
intrinsics::align_of::<T>()
}
core::mem::droppub fn drop<T>(_x: T) {}
core::mem::size_ofpub const fn size_of<T>() -> usize {
intrinsics::size_of::<T>()
}
core::num::<impl u128>::count_ones pub const fn count_ones(self) -> u32 {
return intrinsics::ctpop(self);
}
core::num::<impl u128>::is_power_of_two pub const fn is_power_of_two(self) -> bool {
self.count_ones() == 1
}
core::num::<impl u16>::count_ones pub const fn count_ones(self) -> u32 {
return intrinsics::ctpop(self);
}
core::num::<impl u16>::is_power_of_two pub const fn is_power_of_two(self) -> bool {
self.count_ones() == 1
}
core::num::<impl u32>::count_ones pub const fn count_ones(self) -> u32 {
return intrinsics::ctpop(self);
}
core::num::<impl u32>::is_power_of_two pub const fn is_power_of_two(self) -> bool {
self.count_ones() == 1
}
core::num::<impl u64>::count_ones pub const fn count_ones(self) -> u32 {
return intrinsics::ctpop(self);
}
core::num::<impl u64>::is_power_of_two pub const fn is_power_of_two(self) -> bool {
self.count_ones() == 1
}
core::num::<impl u8>::count_ones pub const fn count_ones(self) -> u32 {
return intrinsics::ctpop(self);
}
core::num::<impl u8>::is_power_of_two pub const fn is_power_of_two(self) -> bool {
self.count_ones() == 1
}
core::num::<impl usize>::count_ones pub const fn count_ones(self) -> u32 {
return intrinsics::ctpop(self);
}
core::num::<impl usize>::is_power_of_two pub const fn is_power_of_two(self) -> bool {
self.count_ones() == 1
}
core::ops::control_flow::ControlFlow::<B, C>::break_ok pub fn break_ok(self) -> Result<B, C> {
match self {
ControlFlow::Continue(c) => Err(c),
ControlFlow::Break(b) => Ok(b),
}
}
core::ops::control_flow::ControlFlow::<B, C>::break_value pub fn break_value(self) -> Option<B> {
match self {
ControlFlow::Continue(..) => None,
ControlFlow::Break(x) => Some(x),
}
}
core::ops::control_flow::ControlFlow::<B, C>::continue_ok pub fn continue_ok(self) -> Result<C, B> {
match self {
ControlFlow::Continue(c) => Ok(c),
ControlFlow::Break(b) => Err(b),
}
}
core::ops::control_flow::ControlFlow::<B, C>::continue_value pub fn continue_value(self) -> Option<C> {
match self {
ControlFlow::Continue(x) => Some(x),
ControlFlow::Break(..) => None,
}
}
core::ops::control_flow::ControlFlow::<B, C>::is_break pub fn is_break(&self) -> bool {
matches!(*self, ControlFlow::Break(_))
}
core::ops::control_flow::ControlFlow::<B, C>::is_continue pub fn is_continue(&self) -> bool {
matches!(*self, ControlFlow::Continue(_))
}
core::ops::control_flow::ControlFlow::<B, C>::map_break pub fn map_break<T>(self, f: impl FnOnce(B) -> T) -> ControlFlow<T, C> {
match self {
ControlFlow::Continue(x) => ControlFlow::Continue(x),
ControlFlow::Break(x) => ControlFlow::Break(f(x)),
}
}
core::ops::control_flow::ControlFlow::<B, C>::map_continue pub fn map_continue<T>(self, f: impl FnOnce(C) -> T) -> ControlFlow<B, T> {
match self {
ControlFlow::Continue(x) => ControlFlow::Continue(f(x)),
ControlFlow::Break(x) => ControlFlow::Break(x),
}
}
core::ops::control_flow::ControlFlow::<T, T>::into_value pub const fn into_value(self) -> T {
match self {
ControlFlow::Continue(x) | ControlFlow::Break(x) => x,
}
}
core::ops::function::impls::<impl core::ops::function::Fn<A> for &F>::call extern "rust-call" fn call(&self, args: A) -> F::Output {
(**self).call(args)
}
core::ops::function::impls::<impl core::ops::function::FnMut<A> for &F>::call_mut extern "rust-call" fn call_mut(&mut self, args: A) -> F::Output {
(**self).call(args)
}
core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut extern "rust-call" fn call_mut(&mut self, args: A) -> F::Output {
(*self).call_mut(args)
}
core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once extern "rust-call" fn call_once(self, args: A) -> F::Output {
(*self).call_mut(args)
}
core::ops::range::Bound::<&T>::cloned pub fn cloned(self) -> Bound<T> {
match self {
Bound::Unbounded => Bound::Unbounded,
Bound::Included(x) => Bound::Included(x.clone()),
Bound::Excluded(x) => Bound::Excluded(x.clone()),
}
}
core::ops::range::Bound::<&T>::copied pub fn copied(self) -> Bound<T> {
match self {
Bound::Unbounded => Bound::Unbounded,
Bound::Included(x) => Bound::Included(*x),
Bound::Excluded(x) => Bound::Excluded(*x),
}
}
core::ops::range::Bound::<T>::as_mut pub fn as_mut(&mut self) -> Bound<&mut T> {
match *self {
Included(ref mut x) => Included(x),
Excluded(ref mut x) => Excluded(x),
Unbounded => Unbounded,
}
}
core::ops::range::Bound::<T>::as_ref pub fn as_ref(&self) -> Bound<&T> {
match *self {
Included(ref x) => Included(x),
Excluded(ref x) => Excluded(x),
Unbounded => Unbounded,
}
}
core::ops::range::Bound::<T>::map pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Bound<U> {
match self {
Unbounded => Unbounded,
Included(x) => Included(f(x)),
Excluded(x) => Excluded(f(x)),
}
}
core::ops::range::RangeInclusive::<Idx>::end pub const fn end(&self) -> &Idx {
&self.end
}
core::ops::range::RangeInclusive::<Idx>::new pub const fn new(start: Idx, end: Idx) -> Self {
Self { start, end, exhausted: false }
}
core::ops::range::RangeInclusive::<Idx>::start pub const fn start(&self) -> &Idx {
&self.start
}
core::option::Option::<&T>::cloned pub fn cloned(self) -> Option<T>
where
T: Clone,
{
match self {
Some(t) => Some(t.clone()),
None => None,
}
}
core::option::Option::<&T>::copied pub const fn copied(self) -> Option<T>
where
T: Copy,
{
// FIXME(const-hack): this implementation, which sidesteps using `Option::map` since it's not const
// ready yet, should be reverted when possible to avoid code repetition
match self {
Some(&v) => Some(v),
None => None,
}
}
core::option::Option::<&mut T>::cloned pub fn cloned(self) -> Option<T>
where
T: Clone,
{
match self {
Some(t) => Some(t.clone()),
None => None,
}
}
core::option::Option::<&mut T>::copied pub const fn copied(self) -> Option<T>
where
T: Copy,
{
match self {
Some(&mut t) => Some(t),
None => None,
}
}
core::option::Option::<(T, U)>::unzip pub fn unzip(self) -> (Option<T>, Option<U>) {
match self {
Some((a, b)) => (Some(a), Some(b)),
None => (None, None),
}
}
core::option::Option::<T>::and pub const fn and<U>(self, optb: Option<U>) -> Option<U>
where
T: [const] Destruct,
U: [const] Destruct,
{
match self {
Some(_) => optb,
None => None,
}
}
core::option::Option::<T>::and_then pub const fn and_then<U, F>(self, f: F) -> Option<U>
where
F: [const] FnOnce(T) -> Option<U> + [const] Destruct,
{
match self {
Some(x) => f(x),
None => None,
}
}
core::option::Option::<T>::as_deref pub const fn as_deref(&self) -> Option<&T::Target>
where
T: [const] Deref,
{
self.as_ref().map(Deref::deref)
}
core::option::Option::<T>::as_deref_mut pub const fn as_deref_mut(&mut self) -> Option<&mut T::Target>
where
T: [const] DerefMut,
{
self.as_mut().map(DerefMut::deref_mut)
}
core::option::Option::<T>::as_mut pub const fn as_mut(&mut self) -> Option<&mut T> {
match *self {
Some(ref mut x) => Some(x),
None => None,
}
}
core::option::Option::<T>::as_ref pub const fn as_ref(&self) -> Option<&T> {
match *self {
Some(ref x) => Some(x),
None => None,
}
}
core::option::Option::<T>::filter pub const fn filter<P>(self, predicate: P) -> Self
where
P: [const] FnOnce(&T) -> bool + [const] Destruct,
T: [const] Destruct,
{
if let Some(x) = self {
// Ferrocene annotation: This function is thoroughly tested inside the `option_methods`
// test in `coretests`. Additionally, the `filter_option` test guarantees that
// `predicate` is being called by panicking inside the `predicate` body and marking the
// test as `#[should_panic]`.
if predicate(&x) {
return Some(x);
}
}
None
}
core::option::Option::<T>::inspect pub const fn inspect<F>(self, f: F) -> Self
where
F: [const] FnOnce(&T) + [const] Destruct,
{
if let Some(ref x) = self {
// Ferrocene annotation: This function is thoroughly tested inside the `option_methods`
// test in `coretests`. Additionally, the `inspect_option` test guarantees that `f` is
// being called by panicking inside the `predicate` body and marking the test as
// `#[should_panic]`.
f(x);
}
self
}
core::option::Option::<T>::is_none_or pub const fn is_none_or(self, f: impl [const] FnOnce(T) -> bool + [const] Destruct) -> bool {
match self {
None => true,
Some(x) => f(x),
}
}
core::option::Option::<T>::is_some pub const fn is_some(&self) -> bool {
matches!(*self, Some(_))
}
core::option::Option::<T>::is_some_and pub const fn is_some_and(self, f: impl [const] FnOnce(T) -> bool + [const] Destruct) -> bool {
match self {
None => false,
Some(x) => f(x),
}
}
core::option::Option::<T>::iter pub fn iter(&self) -> Iter<'_, T> {
Iter { inner: Item { opt: self.as_ref() } }
}
core::option::Option::<T>::iter_mut pub fn iter_mut(&mut self) -> IterMut<'_, T> {
IterMut { inner: Item { opt: self.as_mut() } }
}
core::option::Option::<T>::map pub const fn map<U, F>(self, f: F) -> Option<U>
where
F: [const] FnOnce(T) -> U + [const] Destruct,
{
match self {
Some(x) => Some(f(x)),
None => None,
}
}
core::option::Option::<T>::map_or pub const fn map_or<U, F>(self, default: U, f: F) -> U
where
F: [const] FnOnce(T) -> U + [const] Destruct,
U: [const] Destruct,
{
match self {
Some(t) => f(t),
None => default,
}
}
core::option::Option::<T>::map_or_default pub const fn map_or_default<U, F>(self, f: F) -> U
where
U: [const] Default,
F: [const] FnOnce(T) -> U + [const] Destruct,
{
match self {
Some(t) => f(t),
None => U::default(),
}
}
core::option::Option::<T>::map_or_else pub const fn map_or_else<U, D, F>(self, default: D, f: F) -> U
where
D: [const] FnOnce() -> U + [const] Destruct,
F: [const] FnOnce(T) -> U + [const] Destruct,
{
match self {
Some(t) => f(t),
None => default(),
}
}
core::option::Option::<T>::ok_or pub const fn ok_or<E: [const] Destruct>(self, err: E) -> Result<T, E> {
match self {
Some(v) => Ok(v),
None => Err(err),
}
}
core::option::Option::<T>::ok_or_else pub const fn ok_or_else<E, F>(self, err: F) -> Result<T, E>
where
F: [const] FnOnce() -> E + [const] Destruct,
{
match self {
Some(v) => Ok(v),
None => Err(err()),
}
}
core::option::Option::<T>::or pub const fn or(self, optb: Option<T>) -> Option<T>
where
T: [const] Destruct,
{
match self {
x @ Some(_) => x,
None => optb,
}
}
core::option::Option::<T>::or_else pub const fn or_else<F>(self, f: F) -> Option<T>
where
F: [const] FnOnce() -> Option<T> + [const] Destruct,
//FIXME(const_hack): this `T: [const] Destruct` is unnecessary, but even precise live drops can't tell
// no value of type `T` gets dropped here
T: [const] Destruct,
{
match self {
x @ Some(_) => x,
None => f(),
}
}
core::option::Option::<T>::reduce pub fn reduce<U, R, F>(self, other: Option<U>, f: F) -> Option<R>
where
T: Into<R>,
U: Into<R>,
F: FnOnce(T, U) -> R,
{
match (self, other) {
(Some(a), Some(b)) => Some(f(a, b)),
(Some(a), _) => Some(a.into()),
(_, Some(b)) => Some(b.into()),
_ => None,
}
}
core::option::Option::<T>::unwrap_or pub const fn unwrap_or(self, default: T) -> T
where
T: [const] Destruct,
{
match self {
Some(x) => x,
None => default,
}
}
core::option::Option::<T>::unwrap_or_default pub const fn unwrap_or_default(self) -> T
where
T: [const] Default,
{
match self {
Some(x) => x,
None => T::default(),
}
}
core::option::Option::<T>::unwrap_or_else pub const fn unwrap_or_else<F>(self, f: F) -> T
where
F: [const] FnOnce() -> T + [const] Destruct,
{
match self {
Some(x) => x,
None => f(),
}
}
core::option::Option::<T>::xor pub const fn xor(self, optb: Option<T>) -> Option<T>
where
T: [const] Destruct,
{
match (self, optb) {
(a @ Some(_), None) => a,
(None, b @ Some(_)) => b,
_ => None,
}
}
core::option::Option::<T>::zip pub const fn zip<U>(self, other: Option<U>) -> Option<(T, U)>
where
T: [const] Destruct,
U: [const] Destruct,
{
match (self, other) {
(Some(a), Some(b)) => Some((a, b)),
_ => None,
}
}
core::option::Option::<core::option::Option<T>>::flatten pub const fn flatten(self) -> Option<T> {
// FIXME(const-hack): could be written with `and_then`
match self {
Some(inner) => inner,
None => None,
}
}
core::option::Option::<core::result::Result<T, E>>::transpose pub const fn transpose(self) -> Result<Option<T>, E> {
match self {
Some(Ok(x)) => Ok(Some(x)),
Some(Err(e)) => Err(e),
None => Ok(None),
}
}
core::panic::location::Location::<'a>::column pub const fn column(&self) -> u32 {
self.col
}
core::panic::location::Location::<'a>::line pub const fn line(&self) -> u32 {
self.line
}
core::panicking::panic_nounwind_fmt::runtime fn runtime$(<$($binders)*>)?($($arg: $ty),*) $( -> $ret )? {
$runtime
}
core::ptr::alignment::Alignment::as_usize pub const fn as_usize(self) -> usize {
self.0 as usize
}
core::ptr::alignment::Alignment::new pub const fn new(align: usize) -> Option<Self> {
if align.is_power_of_two() {
// SAFETY: Just checked it only has one bit set
Some(unsafe { Self::new_unchecked(align) })
} else {
None
}
}
core::ptr::alignment::Alignment::new_unchecked pub const unsafe fn new_unchecked(align: usize) -> Self {
assert_unsafe_precondition!(
check_language_ub,
"Alignment::new_unchecked requires a power of two",
(align: usize = align) => align.is_power_of_two()
);
// SAFETY: By precondition, this must be a power of two, and
// our variants encompass all possible powers of two.
unsafe { mem::transmute::<usize, Alignment>(align) }
}
core::ptr::const_ptr::<impl *const T>::addr pub fn addr(self) -> usize {
// A pointer-to-integer transmute currently has exactly the right semantics: it returns the
// address without exposing the provenance. Note that this is *not* a stable guarantee about
// transmute semantics, it relies on sysroot crates having special status.
// SAFETY: Pointer-to-integer transmutes are valid (if you are okay with losing the
// provenance).
unsafe { mem::transmute(self.cast::<()>()) }
}
core::ptr::const_ptr::<impl *const T>::cast pub const fn cast<U>(self) -> *const U {
self as _
}
core::ptr::const_ptr::<impl *const T>::cast_array pub const fn cast_array<const N: usize>(self) -> *const [T; N] {
self.cast()
}
core::ptr::const_ptr::<impl *const T>::is_aligned_to pub fn is_aligned_to(self, align: usize) -> bool {
if !align.is_power_of_two() {
panic!("is_aligned_to: align is not a power-of-two");
}
self.addr() & (align - 1) == 0
}
core::ptr::const_ptr::<impl *const T>::is_null pub const fn is_null(self) -> bool {
// Compare via a cast to a thin pointer, so fat pointers are only
// considering their "data" part for null-ness.
let ptr = self as *const u8;
const_eval_select!(
@capture { ptr: *const u8 } -> bool:
// This use of `const_raw_ptr_comparison` has been explicitly blessed by t-lang.
if const #[rustc_allow_const_fn_unstable(const_raw_ptr_comparison)] {
match (ptr).guaranteed_eq(null_mut()) {
Some(res) => res,
// To remain maximally conservative, we stop execution when we don't
// know whether the pointer is null or not.
// We can *not* return `false` here, that would be unsound in `NonNull::new`!
None => panic!("null-ness of this pointer cannot be determined in const context"),
}
} else {
ptr.addr() == 0
}
)
}
core::ptr::const_ptr::<impl *const T>::is_null::runtime fn runtime$(<$($binders)*>)?($($arg: $ty),*) $( -> $ret )? {
$runtime
}
core::ptr::const_ptr::<impl *const T>::try_cast_aligned pub fn try_cast_aligned<U>(self) -> Option<*const U> {
if self.is_aligned_to(align_of::<U>()) { Some(self.cast()) } else { None }
}
core::ptr::const_ptr::<impl core::cmp::PartialEq for *const T>::eq fn eq(&self, other: &*const T) -> bool {
*self == *other
}
core::ptr::metadata::from_raw_partspub const fn from_raw_parts<T: PointeeSized>(
data_pointer: *const impl Thin,
metadata: <T as Pointee>::Metadata,
) -> *const T {
aggregate_raw_ptr(data_pointer, metadata)
}
core::ptr::metadata::from_raw_parts_mutpub const fn from_raw_parts_mut<T: PointeeSized>(
data_pointer: *mut impl Thin,
metadata: <T as Pointee>::Metadata,
) -> *mut T {
aggregate_raw_ptr(data_pointer, metadata)
}
core::ptr::mut_ptr::<impl *mut T>::cast pub const fn cast<U>(self) -> *mut U {
self as _
}
core::ptr::mut_ptr::<impl *mut T>::cast_array pub const fn cast_array<const N: usize>(self) -> *mut [T; N] {
self.cast()
}
core::ptr::nullpub const fn null<T: PointeeSized + Thin>() -> *const T {
from_raw_parts(without_provenance::<()>(0), ())
}
core::ptr::null_mutpub const fn null_mut<T: PointeeSized + Thin>() -> *mut T {
from_raw_parts_mut(without_provenance_mut::<()>(0), ())
}
core::ptr::readpub const unsafe fn read<T>(src: *const T) -> T {
// It would be semantically correct to implement this via `copy_nonoverlapping`
// and `MaybeUninit`, as was done before PR #109035. Calling `assume_init`
// provides enough information to know that this is a typed operation.
// However, as of March 2023 the compiler was not capable of taking advantage
// of that information. Thus, the implementation here switched to an intrinsic,
// which lowers to `_0 = *src` in MIR, to address a few issues:
//
// - Using `MaybeUninit::assume_init` after a `copy_nonoverlapping` was not
// turning the untyped copy into a typed load. As such, the generated
// `load` in LLVM didn't get various metadata, such as `!range` (#73258),
// `!nonnull`, and `!noundef`, resulting in poorer optimization.
// - Going through the extra local resulted in multiple extra copies, even
// in optimized MIR. (Ignoring StorageLive/Dead, the intrinsic is one
// MIR statement, while the previous implementation was eight.) LLVM
// could sometimes optimize them away, but because `read` is at the core
// of so many things, not having them in the first place improves what we
// hand off to the backend. For example, `mem::replace::<Big>` previously
// emitted 4 `alloca` and 6 `memcpy`s, but is now 1 `alloc` and 3 `memcpy`s.
// - In general, this approach keeps us from getting any more bugs (like
// #106369) that boil down to "`read(p)` is worse than `*p`", as this
// makes them look identical to the backend (or other MIR consumers).
//
// Future enhancements to MIR optimizations might well allow this to return
// to the previous implementation, rather than using an intrinsic.
// SAFETY: the caller must guarantee that `src` is valid for reads.
unsafe {
#[cfg(debug_assertions)] // Too expensive to always enable (for now?)
ub_checks::assert_unsafe_precondition!(
check_language_ub,
"ptr::read requires that the pointer argument is aligned and non-null",
(
addr: *const () = src as *const (),
align: usize = align_of::<T>(),
is_zst: bool = T::IS_ZST,
) => ub_checks::maybe_is_aligned_and_not_null(addr, align, is_zst)
);
crate::intrinsics::read_via_copy(src)
}
}
core::ptr::without_provenancepub const fn without_provenance<T>(addr: usize) -> *const T {
without_provenance_mut(addr)
}
core::ptr::without_provenance_mutpub const fn without_provenance_mut<T>(addr: usize) -> *mut T {
// An int-to-pointer transmute currently has exactly the intended semantics: it creates a
// pointer without provenance. Note that this is *not* a stable guarantee about transmute
// semantics, it relies on sysroot crates having special status.
// SAFETY: every valid integer is also a valid pointer (as long as you don't dereference that
// pointer).
unsafe { mem::transmute(addr) }
}
core::ptr::writepub const unsafe fn write<T>(dst: *mut T, src: T) {
// Semantically, it would be fine for this to be implemented as a
// `copy_nonoverlapping` and appropriate drop suppression of `src`.
// However, implementing via that currently produces more MIR than is ideal.
// Using an intrinsic keeps it down to just the simple `*dst = move src` in
// MIR (11 statements shorter, at the time of writing), and also allows
// `src` to stay an SSA value in codegen_ssa, rather than a memory one.
// SAFETY: the caller must guarantee that `dst` is valid for writes.
// `dst` cannot overlap `src` because the caller has mutable access
// to `dst` while `src` is owned by this function.
unsafe {
#[cfg(debug_assertions)] // Too expensive to always enable (for now?)
ub_checks::assert_unsafe_precondition!(
check_language_ub,
"ptr::write requires that the pointer argument is aligned and non-null",
(
addr: *mut () = dst as *mut (),
align: usize = align_of::<T>(),
is_zst: bool = T::IS_ZST,
) => ub_checks::maybe_is_aligned_and_not_null(addr, align, is_zst)
);
intrinsics::write_via_move(dst, src)
}
}
core::result::Result::<&T, E>::cloned pub fn cloned(self) -> Result<T, E>
where
T: Clone,
{
self.map(|t| t.clone())
}
core::result::Result::<&T, E>::copied pub const fn copied(self) -> Result<T, E>
where
T: Copy,
{
// FIXME(const-hack): this implementation, which sidesteps using `Result::map` since it's not const
// ready yet, should be reverted when possible to avoid code repetition
match self {
Ok(&v) => Ok(v),
Err(e) => Err(e),
}
}
core::result::Result::<&mut T, E>::cloned pub fn cloned(self) -> Result<T, E>
where
T: Clone,
{
self.map(|t| t.clone())
}
core::result::Result::<&mut T, E>::copied pub const fn copied(self) -> Result<T, E>
where
T: Copy,
{
// FIXME(const-hack): this implementation, which sidesteps using `Result::map` since it's not const
// ready yet, should be reverted when possible to avoid code repetition
match self {
Ok(&mut v) => Ok(v),
Err(e) => Err(e),
}
}
core::result::Result::<T, E>::and pub const fn and<U>(self, res: Result<U, E>) -> Result<U, E>
where
T: [const] Destruct,
E: [const] Destruct,
U: [const] Destruct,
{
match self {
Ok(_) => res,
Err(e) => Err(e),
}
}
core::result::Result::<T, E>::and_then pub const fn and_then<U, F>(self, op: F) -> Result<U, E>
where
F: [const] FnOnce(T) -> Result<U, E> + [const] Destruct,
{
match self {
Ok(t) => op(t),
Err(e) => Err(e),
}
}
core::result::Result::<T, E>::as_deref pub const fn as_deref(&self) -> Result<&T::Target, &E>
where
T: [const] Deref,
{
self.as_ref().map(Deref::deref)
}
core::result::Result::<T, E>::as_deref_mut pub const fn as_deref_mut(&mut self) -> Result<&mut T::Target, &mut E>
where
T: [const] DerefMut,
{
self.as_mut().map(DerefMut::deref_mut)
}
core::result::Result::<T, E>::as_mut pub const fn as_mut(&mut self) -> Result<&mut T, &mut E> {
match *self {
Ok(ref mut x) => Ok(x),
Err(ref mut x) => Err(x),
}
}
core::result::Result::<T, E>::as_ref pub const fn as_ref(&self) -> Result<&T, &E> {
match *self {
Ok(ref x) => Ok(x),
Err(ref x) => Err(x),
}
}
core::result::Result::<T, E>::err pub const fn err(self) -> Option<E>
where
T: [const] Destruct,
E: [const] Destruct,
{
match self {
Ok(_) => None,
Err(x) => Some(x),
}
}
core::result::Result::<T, E>::inspect pub const fn inspect<F>(self, f: F) -> Self
where
F: [const] FnOnce(&T) + [const] Destruct,
{
if let Ok(ref t) = self {
// Ferrocene annotation: This function is thoroughly tested inside the `result_methods`
// test in `coretests`. Additionally, the `inspect_result` test guarantees that `f` is
// being called by panicking inside the `predicate` body and marking the test as
// `#[should_panic]`.
f(t);
}
self
}
core::result::Result::<T, E>::inspect_err pub const fn inspect_err<F>(self, f: F) -> Self
where
F: [const] FnOnce(&E) + [const] Destruct,
{
if let Err(ref e) = self {
// Ferrocene annotation: This function is thoroughly tested inside the `result_methods`
// test in `coretests`. Additionally, the `inspect_result_err` test guarantees that `f`
// is being called by panicking inside the `predicate` body and marking the test as
// `#[should_panic]`.
f(e);
}
self
}
core::result::Result::<T, E>::is_err pub const fn is_err(&self) -> bool {
!self.is_ok()
}
core::result::Result::<T, E>::is_err_and pub const fn is_err_and<F>(self, f: F) -> bool
where
F: [const] FnOnce(E) -> bool + [const] Destruct,
E: [const] Destruct,
T: [const] Destruct,
{
match self {
Ok(_) => false,
Err(e) => f(e),
}
}
core::result::Result::<T, E>::is_ok pub const fn is_ok(&self) -> bool {
matches!(*self, Ok(_))
}
core::result::Result::<T, E>::is_ok_and pub const fn is_ok_and<F>(self, f: F) -> bool
where
F: [const] FnOnce(T) -> bool + [const] Destruct,
T: [const] Destruct,
E: [const] Destruct,
{
match self {
Err(_) => false,
Ok(x) => f(x),
}
}
core::result::Result::<T, E>::map pub const fn map<U, F>(self, op: F) -> Result<U, E>
where
F: [const] FnOnce(T) -> U + [const] Destruct,
{
match self {
Ok(t) => Ok(op(t)),
Err(e) => Err(e),
}
}
core::result::Result::<T, E>::map_err pub const fn map_err<F, O>(self, op: O) -> Result<T, F>
where
O: [const] FnOnce(E) -> F + [const] Destruct,
{
match self {
Ok(t) => Ok(t),
Err(e) => Err(op(e)),
}
}
core::result::Result::<T, E>::map_or pub const fn map_or<U, F>(self, default: U, f: F) -> U
where
F: [const] FnOnce(T) -> U + [const] Destruct,
T: [const] Destruct,
E: [const] Destruct,
U: [const] Destruct,
{
match self {
Ok(t) => f(t),
Err(_) => default,
}
}
core::result::Result::<T, E>::map_or_default pub const fn map_or_default<U, F>(self, f: F) -> U
where
F: [const] FnOnce(T) -> U + [const] Destruct,
U: [const] Default,
T: [const] Destruct,
E: [const] Destruct,
{
match self {
Ok(t) => f(t),
Err(_) => U::default(),
}
}
core::result::Result::<T, E>::map_or_else pub const fn map_or_else<U, D, F>(self, default: D, f: F) -> U
where
D: [const] FnOnce(E) -> U + [const] Destruct,
F: [const] FnOnce(T) -> U + [const] Destruct,
{
match self {
Ok(t) => f(t),
Err(e) => default(e),
}
}
core::result::Result::<T, E>::ok pub const fn ok(self) -> Option<T>
where
T: [const] Destruct,
E: [const] Destruct,
{
match self {
Ok(x) => Some(x),
Err(_) => None,
}
}
core::result::Result::<T, E>::or pub const fn or<F>(self, res: Result<T, F>) -> Result<T, F>
where
T: [const] Destruct,
E: [const] Destruct,
F: [const] Destruct,
{
match self {
Ok(v) => Ok(v),
Err(_) => res,
}
}
core::result::Result::<T, E>::or_else pub const fn or_else<F, O>(self, op: O) -> Result<T, F>
where
O: [const] FnOnce(E) -> Result<T, F> + [const] Destruct,
{
match self {
Ok(t) => Ok(t),
Err(e) => op(e),
}
}
core::result::Result::<T, E>::unwrap_or pub const fn unwrap_or(self, default: T) -> T
where
T: [const] Destruct,
E: [const] Destruct,
{
match self {
Ok(t) => t,
Err(_) => default,
}
}
core::result::Result::<T, E>::unwrap_or_default pub const fn unwrap_or_default(self) -> T
where
T: [const] Default + [const] Destruct,
E: [const] Destruct,
{
match self {
Ok(x) => x,
Err(_) => Default::default(),
}
}
core::result::Result::<T, E>::unwrap_or_else pub const fn unwrap_or_else<F>(self, op: F) -> T
where
F: [const] FnOnce(E) -> T + [const] Destruct,
{
match self {
Ok(t) => t,
Err(e) => op(e),
}
}
core::result::Result::<core::option::Option<T>, E>::transpose pub const fn transpose(self) -> Option<Result<T, E>> {
match self {
Ok(Some(x)) => Some(Ok(x)),
Ok(None) => None,
Err(e) => Some(Err(e)),
}
}
core::sync::atomic::AtomicU32::as_ptr pub const fn as_ptr(&self) -> *mut $int_type {
self.v.get()
}
core::sync::atomic::AtomicU32::compare_exchange pub fn compare_exchange(&self,
current: $int_type,
new: $int_type,
success: Ordering,
failure: Ordering) -> Result<$int_type, $int_type> {
// SAFETY: data races are prevented by atomic intrinsics.
unsafe { atomic_compare_exchange(self.v.get(), current, new, success, failure) }
}
core::sync::atomic::AtomicU32::compare_exchange_weak pub fn compare_exchange_weak(&self,
current: $int_type,
new: $int_type,
success: Ordering,
failure: Ordering) -> Result<$int_type, $int_type> {
// SAFETY: data races are prevented by atomic intrinsics.
unsafe {
atomic_compare_exchange_weak(self.v.get(), current, new, success, failure)
}
}
core::sync::atomic::AtomicU32::fetch_add pub fn fetch_add(&self, val: $int_type, order: Ordering) -> $int_type {
// SAFETY: data races are prevented by atomic intrinsics.
unsafe { atomic_add(self.v.get(), val, order) }
}
core::sync::atomic::AtomicU32::fetch_and pub fn fetch_and(&self, val: $int_type, order: Ordering) -> $int_type {
// SAFETY: data races are prevented by atomic intrinsics.
unsafe { atomic_and(self.v.get(), val, order) }
}
core::sync::atomic::AtomicU32::fetch_max pub fn fetch_max(&self, val: $int_type, order: Ordering) -> $int_type {
// SAFETY: data races are prevented by atomic intrinsics.
unsafe { $max_fn(self.v.get(), val, order) }
}
core::sync::atomic::AtomicU32::fetch_min pub fn fetch_min(&self, val: $int_type, order: Ordering) -> $int_type {
// SAFETY: data races are prevented by atomic intrinsics.
unsafe { $min_fn(self.v.get(), val, order) }
}
core::sync::atomic::AtomicU32::fetch_nand pub fn fetch_nand(&self, val: $int_type, order: Ordering) -> $int_type {
// SAFETY: data races are prevented by atomic intrinsics.
unsafe { atomic_nand(self.v.get(), val, order) }
}
core::sync::atomic::AtomicU32::fetch_or pub fn fetch_or(&self, val: $int_type, order: Ordering) -> $int_type {
// SAFETY: data races are prevented by atomic intrinsics.
unsafe { atomic_or(self.v.get(), val, order) }
}
core::sync::atomic::AtomicU32::fetch_sub pub fn fetch_sub(&self, val: $int_type, order: Ordering) -> $int_type {
// SAFETY: data races are prevented by atomic intrinsics.
unsafe { atomic_sub(self.v.get(), val, order) }
}
core::sync::atomic::AtomicU32::fetch_update pub fn fetch_update<F>(&self,
set_order: Ordering,
fetch_order: Ordering,
mut f: F) -> Result<$int_type, $int_type>
where F: FnMut($int_type) -> Option<$int_type> {
let mut prev = self.load(fetch_order);
while let Some(next) = f(prev) {
// Ferrocene annotation: Both arms of this match expression are covered, which
// means that scrutinee expression itself must have been evaluated in either
// case.
match self.compare_exchange_weak(prev, next, set_order, fetch_order) {
x @ Ok(_) => return x,
Err(next_prev) => prev = next_prev
}
}
Err(prev)
}
core::sync::atomic::AtomicU32::fetch_xor pub fn fetch_xor(&self, val: $int_type, order: Ordering) -> $int_type {
// SAFETY: data races are prevented by atomic intrinsics.
unsafe { atomic_xor(self.v.get(), val, order) }
}
core::sync::atomic::AtomicU32::from_mut pub fn from_mut(v: &mut $int_type) -> &mut Self {
let [] = [(); align_of::<Self>() - align_of::<$int_type>()];
// SAFETY:
// - the mutable reference guarantees unique ownership.
// - the alignment of `$int_type` and `Self` is the
// same, as promised by $cfg_align and verified above.
unsafe { &mut *(v as *mut $int_type as *mut Self) }
}
core::sync::atomic::AtomicU32::from_mut_slice pub fn from_mut_slice(v: &mut [$int_type]) -> &mut [Self] {
let [] = [(); align_of::<Self>() - align_of::<$int_type>()];
// SAFETY:
// - the mutable reference guarantees unique ownership.
// - the alignment of `$int_type` and `Self` is the
// same, as promised by $cfg_align and verified above.
unsafe { &mut *(v as *mut [$int_type] as *mut [Self]) }
}
core::sync::atomic::AtomicU32::from_ptr pub const unsafe fn from_ptr<'a>(ptr: *mut $int_type) -> &'a $atomic_type {
// SAFETY: guaranteed by the caller
unsafe { &*ptr.cast() }
}
core::sync::atomic::AtomicU32::get_mut pub fn get_mut(&mut self) -> &mut $int_type {
self.v.get_mut()
}
core::sync::atomic::AtomicU32::get_mut_slice pub fn get_mut_slice(this: &mut [Self]) -> &mut [$int_type] {
// SAFETY: the mutable reference guarantees unique ownership.
unsafe { &mut *(this as *mut [Self] as *mut [$int_type]) }
}
core::sync::atomic::AtomicU32::into_inner pub const fn into_inner(self) -> $int_type {
self.v.into_inner()
}
core::sync::atomic::AtomicU32::load pub fn load(&self, order: Ordering) -> $int_type {
// SAFETY: data races are prevented by atomic intrinsics.
unsafe { atomic_load(self.v.get(), order) }
}
core::sync::atomic::AtomicU32::new pub const fn new(v: $int_type) -> Self {
Self {v: UnsafeCell::new(v)}
}
core::sync::atomic::AtomicU32::store pub fn store(&self, val: $int_type, order: Ordering) {
// SAFETY: data races are prevented by atomic intrinsics.
unsafe { atomic_store(self.v.get(), val, order); }
}
core::sync::atomic::AtomicU32::swap pub fn swap(&self, val: $int_type, order: Ordering) -> $int_type {
// SAFETY: data races are prevented by atomic intrinsics.
unsafe { atomic_swap(self.v.get(), val, order) }
}
core::sync::atomic::AtomicU32::try_update pub fn try_update(
&self,
set_order: Ordering,
fetch_order: Ordering,
f: impl FnMut($int_type) -> Option<$int_type>,
) -> Result<$int_type, $int_type> {
// FIXME(atomic_try_update): this is currently an unstable alias to `fetch_update`;
// when stabilizing, turn `fetch_update` into a deprecated alias to `try_update`.
self.fetch_update(set_order, fetch_order, f)
}
core::sync::atomic::AtomicU32::update pub fn update(
&self,
set_order: Ordering,
fetch_order: Ordering,
mut f: impl FnMut($int_type) -> $int_type,
) -> $int_type {
let mut prev = self.load(fetch_order);
loop {
match self.compare_exchange_weak(prev, f(prev), set_order, fetch_order) {
Ok(x) => break x,
Err(next_prev) => prev = next_prev,
}
}
}
core::sync::atomic::atomic_addunsafe fn atomic_add<T: Copy, U: Copy>(dst: *mut T, val: U, order: Ordering) -> T {
// SAFETY: the caller must uphold the safety contract for `atomic_add`.
unsafe {
match order {
Relaxed => intrinsics::atomic_xadd::<T, U, { AO::Relaxed }>(dst, val),
Acquire => intrinsics::atomic_xadd::<T, U, { AO::Acquire }>(dst, val),
Release => intrinsics::atomic_xadd::<T, U, { AO::Release }>(dst, val),
AcqRel => intrinsics::atomic_xadd::<T, U, { AO::AcqRel }>(dst, val),
SeqCst => intrinsics::atomic_xadd::<T, U, { AO::SeqCst }>(dst, val),
}
}
}
core::sync::atomic::atomic_andunsafe fn atomic_and<T: Copy, U: Copy>(dst: *mut T, val: U, order: Ordering) -> T {
// SAFETY: the caller must uphold the safety contract for `atomic_and`
unsafe {
match order {
Relaxed => intrinsics::atomic_and::<T, U, { AO::Relaxed }>(dst, val),
Acquire => intrinsics::atomic_and::<T, U, { AO::Acquire }>(dst, val),
Release => intrinsics::atomic_and::<T, U, { AO::Release }>(dst, val),
AcqRel => intrinsics::atomic_and::<T, U, { AO::AcqRel }>(dst, val),
SeqCst => intrinsics::atomic_and::<T, U, { AO::SeqCst }>(dst, val),
}
}
}
core::sync::atomic::atomic_compare_exchangepub unsafe fn atomic_compare_exchange<T: Copy>(
dst: *mut T,
old: T,
new: T,
success: Ordering,
failure: Ordering,
) -> Result<T, T> {
// SAFETY: the caller must uphold the safety contract for `atomic_compare_exchange`.
let (val, ok) = unsafe {
match (success, failure) {
(Relaxed, Relaxed) => {
intrinsics::atomic_cxchg::<T, { AO::Relaxed }, { AO::Relaxed }>(dst, old, new)
}
(Relaxed, Acquire) => {
intrinsics::atomic_cxchg::<T, { AO::Relaxed }, { AO::Acquire }>(dst, old, new)
}
(Relaxed, SeqCst) => {
intrinsics::atomic_cxchg::<T, { AO::Relaxed }, { AO::SeqCst }>(dst, old, new)
}
(Acquire, Relaxed) => {
intrinsics::atomic_cxchg::<T, { AO::Acquire }, { AO::Relaxed }>(dst, old, new)
}
(Acquire, Acquire) => {
intrinsics::atomic_cxchg::<T, { AO::Acquire }, { AO::Acquire }>(dst, old, new)
}
(Acquire, SeqCst) => {
intrinsics::atomic_cxchg::<T, { AO::Acquire }, { AO::SeqCst }>(dst, old, new)
}
(Release, Relaxed) => {
intrinsics::atomic_cxchg::<T, { AO::Release }, { AO::Relaxed }>(dst, old, new)
}
(Release, Acquire) => {
intrinsics::atomic_cxchg::<T, { AO::Release }, { AO::Acquire }>(dst, old, new)
}
(Release, SeqCst) => {
intrinsics::atomic_cxchg::<T, { AO::Release }, { AO::SeqCst }>(dst, old, new)
}
(AcqRel, Relaxed) => {
intrinsics::atomic_cxchg::<T, { AO::AcqRel }, { AO::Relaxed }>(dst, old, new)
}
(AcqRel, Acquire) => {
intrinsics::atomic_cxchg::<T, { AO::AcqRel }, { AO::Acquire }>(dst, old, new)
}
(AcqRel, SeqCst) => {
intrinsics::atomic_cxchg::<T, { AO::AcqRel }, { AO::SeqCst }>(dst, old, new)
}
(SeqCst, Relaxed) => {
intrinsics::atomic_cxchg::<T, { AO::SeqCst }, { AO::Relaxed }>(dst, old, new)
}
(SeqCst, Acquire) => {
intrinsics::atomic_cxchg::<T, { AO::SeqCst }, { AO::Acquire }>(dst, old, new)
}
(SeqCst, SeqCst) => {
intrinsics::atomic_cxchg::<T, { AO::SeqCst }, { AO::SeqCst }>(dst, old, new)
}
(_, AcqRel) => panic!("there is no such thing as an acquire-release failure ordering"),
(_, Release) => panic!("there is no such thing as a release failure ordering"),
}
};
// Ferrocene annotation: Both branches of this conditional are covered, which means that the
// `ok` boolean must have been evaluated in either case.
if ok {
//
Ok(val)
} else {
//
Err(val)
}
}
core::sync::atomic::atomic_compare_exchange_weakunsafe fn atomic_compare_exchange_weak<T: Copy>(
dst: *mut T,
old: T,
new: T,
success: Ordering,
failure: Ordering,
) -> Result<T, T> {
// SAFETY: the caller must uphold the safety contract for `atomic_compare_exchange_weak`.
let (val, ok) = unsafe {
match (success, failure) {
(Relaxed, Relaxed) => {
intrinsics::atomic_cxchgweak::<T, { AO::Relaxed }, { AO::Relaxed }>(dst, old, new)
}
(Relaxed, Acquire) => {
intrinsics::atomic_cxchgweak::<T, { AO::Relaxed }, { AO::Acquire }>(dst, old, new)
}
(Relaxed, SeqCst) => {
intrinsics::atomic_cxchgweak::<T, { AO::Relaxed }, { AO::SeqCst }>(dst, old, new)
}
(Acquire, Relaxed) => {
intrinsics::atomic_cxchgweak::<T, { AO::Acquire }, { AO::Relaxed }>(dst, old, new)
}
(Acquire, Acquire) => {
intrinsics::atomic_cxchgweak::<T, { AO::Acquire }, { AO::Acquire }>(dst, old, new)
}
(Acquire, SeqCst) => {
intrinsics::atomic_cxchgweak::<T, { AO::Acquire }, { AO::SeqCst }>(dst, old, new)
}
(Release, Relaxed) => {
intrinsics::atomic_cxchgweak::<T, { AO::Release }, { AO::Relaxed }>(dst, old, new)
}
(Release, Acquire) => {
intrinsics::atomic_cxchgweak::<T, { AO::Release }, { AO::Acquire }>(dst, old, new)
}
(Release, SeqCst) => {
intrinsics::atomic_cxchgweak::<T, { AO::Release }, { AO::SeqCst }>(dst, old, new)
}
(AcqRel, Relaxed) => {
intrinsics::atomic_cxchgweak::<T, { AO::AcqRel }, { AO::Relaxed }>(dst, old, new)
}
(AcqRel, Acquire) => {
intrinsics::atomic_cxchgweak::<T, { AO::AcqRel }, { AO::Acquire }>(dst, old, new)
}
(AcqRel, SeqCst) => {
intrinsics::atomic_cxchgweak::<T, { AO::AcqRel }, { AO::SeqCst }>(dst, old, new)
}
(SeqCst, Relaxed) => {
intrinsics::atomic_cxchgweak::<T, { AO::SeqCst }, { AO::Relaxed }>(dst, old, new)
}
(SeqCst, Acquire) => {
intrinsics::atomic_cxchgweak::<T, { AO::SeqCst }, { AO::Acquire }>(dst, old, new)
}
(SeqCst, SeqCst) => {
intrinsics::atomic_cxchgweak::<T, { AO::SeqCst }, { AO::SeqCst }>(dst, old, new)
}
(_, AcqRel) => panic!("there is no such thing as an acquire-release failure ordering"),
(_, Release) => panic!("there is no such thing as a release failure ordering"),
}
};
// Ferrocene annotation: Both branches of this conditional are covered, which means that the
// `ok` boolean must have been evaluated in either case.
if ok {
//
Ok(val)
} else {
//
Err(val)
}
}
core::sync::atomic::atomic_loadunsafe fn atomic_load<T: Copy>(dst: *const T, order: Ordering) -> T {
// SAFETY: the caller must uphold the safety contract for `atomic_load`.
unsafe {
match order {
Relaxed => intrinsics::atomic_load::<T, { AO::Relaxed }>(dst),
Acquire => intrinsics::atomic_load::<T, { AO::Acquire }>(dst),
SeqCst => intrinsics::atomic_load::<T, { AO::SeqCst }>(dst),
Release => panic!("there is no such thing as a release load"),
AcqRel => panic!("there is no such thing as an acquire-release load"),
}
}
}
core::sync::atomic::atomic_nandunsafe fn atomic_nand<T: Copy, U: Copy>(dst: *mut T, val: U, order: Ordering) -> T {
// SAFETY: the caller must uphold the safety contract for `atomic_nand`
unsafe {
match order {
Relaxed => intrinsics::atomic_nand::<T, U, { AO::Relaxed }>(dst, val),
Acquire => intrinsics::atomic_nand::<T, U, { AO::Acquire }>(dst, val),
Release => intrinsics::atomic_nand::<T, U, { AO::Release }>(dst, val),
AcqRel => intrinsics::atomic_nand::<T, U, { AO::AcqRel }>(dst, val),
SeqCst => intrinsics::atomic_nand::<T, U, { AO::SeqCst }>(dst, val),
}
}
}
core::sync::atomic::atomic_orunsafe fn atomic_or<T: Copy, U: Copy>(dst: *mut T, val: U, order: Ordering) -> T {
// SAFETY: the caller must uphold the safety contract for `atomic_or`
unsafe {
match order {
SeqCst => intrinsics::atomic_or::<T, U, { AO::SeqCst }>(dst, val),
Acquire => intrinsics::atomic_or::<T, U, { AO::Acquire }>(dst, val),
Release => intrinsics::atomic_or::<T, U, { AO::Release }>(dst, val),
AcqRel => intrinsics::atomic_or::<T, U, { AO::AcqRel }>(dst, val),
Relaxed => intrinsics::atomic_or::<T, U, { AO::Relaxed }>(dst, val),
}
}
}
core::sync::atomic::atomic_storeunsafe fn atomic_store<T: Copy>(dst: *mut T, val: T, order: Ordering) {
// SAFETY: the caller must uphold the safety contract for `atomic_store`.
unsafe {
match order {
Relaxed => intrinsics::atomic_store::<T, { AO::Relaxed }>(dst, val),
Release => intrinsics::atomic_store::<T, { AO::Release }>(dst, val),
SeqCst => intrinsics::atomic_store::<T, { AO::SeqCst }>(dst, val),
Acquire => panic!("there is no such thing as an acquire store"),
AcqRel => panic!("there is no such thing as an acquire-release store"),
}
}
}
core::sync::atomic::atomic_subunsafe fn atomic_sub<T: Copy, U: Copy>(dst: *mut T, val: U, order: Ordering) -> T {
// SAFETY: the caller must uphold the safety contract for `atomic_sub`.
unsafe {
match order {
Relaxed => intrinsics::atomic_xsub::<T, U, { AO::Relaxed }>(dst, val),
Acquire => intrinsics::atomic_xsub::<T, U, { AO::Acquire }>(dst, val),
Release => intrinsics::atomic_xsub::<T, U, { AO::Release }>(dst, val),
AcqRel => intrinsics::atomic_xsub::<T, U, { AO::AcqRel }>(dst, val),
SeqCst => intrinsics::atomic_xsub::<T, U, { AO::SeqCst }>(dst, val),
}
}
}
core::sync::atomic::atomic_swapunsafe fn atomic_swap<T: Copy>(dst: *mut T, val: T, order: Ordering) -> T {
// SAFETY: the caller must uphold the safety contract for `atomic_swap`.
unsafe {
match order {
Relaxed => intrinsics::atomic_xchg::<T, { AO::Relaxed }>(dst, val),
Acquire => intrinsics::atomic_xchg::<T, { AO::Acquire }>(dst, val),
Release => intrinsics::atomic_xchg::<T, { AO::Release }>(dst, val),
AcqRel => intrinsics::atomic_xchg::<T, { AO::AcqRel }>(dst, val),
SeqCst => intrinsics::atomic_xchg::<T, { AO::SeqCst }>(dst, val),
}
}
}
core::sync::atomic::atomic_umaxunsafe fn atomic_umax<T: Copy>(dst: *mut T, val: T, order: Ordering) -> T {
// SAFETY: the caller must uphold the safety contract for `atomic_umax`
unsafe {
match order {
Relaxed => intrinsics::atomic_umax::<T, { AO::Relaxed }>(dst, val),
Acquire => intrinsics::atomic_umax::<T, { AO::Acquire }>(dst, val),
Release => intrinsics::atomic_umax::<T, { AO::Release }>(dst, val),
AcqRel => intrinsics::atomic_umax::<T, { AO::AcqRel }>(dst, val),
SeqCst => intrinsics::atomic_umax::<T, { AO::SeqCst }>(dst, val),
}
}
}
core::sync::atomic::atomic_uminunsafe fn atomic_umin<T: Copy>(dst: *mut T, val: T, order: Ordering) -> T {
// SAFETY: the caller must uphold the safety contract for `atomic_umin`
unsafe {
match order {
Relaxed => intrinsics::atomic_umin::<T, { AO::Relaxed }>(dst, val),
Acquire => intrinsics::atomic_umin::<T, { AO::Acquire }>(dst, val),
Release => intrinsics::atomic_umin::<T, { AO::Release }>(dst, val),
AcqRel => intrinsics::atomic_umin::<T, { AO::AcqRel }>(dst, val),
SeqCst => intrinsics::atomic_umin::<T, { AO::SeqCst }>(dst, val),
}
}
}
core::sync::atomic::atomic_xorunsafe fn atomic_xor<T: Copy, U: Copy>(dst: *mut T, val: U, order: Ordering) -> T {
// SAFETY: the caller must uphold the safety contract for `atomic_xor`
unsafe {
match order {
SeqCst => intrinsics::atomic_xor::<T, U, { AO::SeqCst }>(dst, val),
Acquire => intrinsics::atomic_xor::<T, U, { AO::Acquire }>(dst, val),
Release => intrinsics::atomic_xor::<T, U, { AO::Release }>(dst, val),
AcqRel => intrinsics::atomic_xor::<T, U, { AO::AcqRel }>(dst, val),
Relaxed => intrinsics::atomic_xor::<T, U, { AO::Relaxed }>(dst, val),
}
}
}
core::ub_checks::check_language_ubpub(crate) const fn check_language_ub() -> bool {
// Only used for UB checks so we may const_eval_select.
intrinsics::ub_checks()
&& const_eval_select!(
@capture { } -> bool:
if const {
// Always disable UB checks.
false
} else {
// Disable UB checks in Miri.
!cfg!(miri)
}
)
}
core::ub_checks::check_language_ub::runtime fn runtime$(<$($binders)*>)?($($arg: $ty),*) $( -> $ret )? {
$runtime
}
core::ub_checks::maybe_is_alignedpub(crate) const fn maybe_is_aligned(ptr: *const (), align: usize) -> bool {
// This is just for safety checks so we can const_eval_select.
const_eval_select!(
@capture { ptr: *const (), align: usize } -> bool:
if const {
true
} else {
ptr.is_aligned_to(align)
}
)
}
core::ub_checks::maybe_is_aligned::runtime fn runtime$(<$($binders)*>)?($($arg: $ty),*) $( -> $ret )? {
$runtime
}
core::ub_checks::maybe_is_aligned_and_not_nullpub(crate) const fn maybe_is_aligned_and_not_null(
ptr: *const (),
align: usize,
is_zst: bool,
) -> bool {
// This is just for safety checks so we can const_eval_select.
maybe_is_aligned(ptr, align) && (is_zst || !ptr.is_null())
}
<core::convert::Infallible as core::clone::Clone>::clone fn clone(&self) -> Infallible {
match *self {}
}
<core::intrinsics::AtomicOrdering as core::cmp::Eq>::assert_receiver_is_total_eq#[cfg_attr(feature = "ferrocene_certified", derive(ConstParamTy, PartialEq, Eq))]
<core::intrinsics::AtomicOrdering as core::cmp::PartialEq>::eq#[cfg_attr(feature = "ferrocene_certified", derive(ConstParamTy, PartialEq, Eq))]
<core::ptr::alignment::Alignment as core::clone::Clone>::clone#[cfg_attr(feature = "ferrocene_certified", derive(Copy, Clone))]
<core::ptr::alignment::AlignmentEnum as core::clone::Clone>::clone#[derive(Copy, Clone)]
<core::sync::atomic::Ordering as core::clone::Clone>::clone#[cfg_attr(feature = "ferrocene_certified", derive(Copy, Clone))]
core::alloc::layout::Layout::is_size_align_valid const fn is_size_align_valid(size: usize, align: usize) -> bool {
let Some(align) = Alignment::new(align) else { return false };
if size > Self::max_size_for_align(align) {
return false;
}
true
}
core::clone::Clone::clone fn clone(&self) -> Self;
core::clone::impls::<impl core::clone::Clone for *const T>::clone fn clone(&self) -> Self {
*self
}
core::clone::impls::<impl core::clone::Clone for *mut T>::clone fn clone(&self) -> Self {
*self
}
core::cmp::Eq::assert_receiver_is_total_eq fn assert_receiver_is_total_eq(&self) {}
core::cmp::Ord::cmp fn cmp(&self, other: &Self) -> Ordering;
core::cmp::PartialEq::eq fn eq(&self, other: &Rhs) -> bool;
core::cmp::PartialOrd::partial_cmp fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>;
core::convert::AsMut::as_mut fn as_mut(&mut self) -> &mut T;
core::convert::AsRef::as_ref fn as_ref(&self) -> &T;
core::convert::From::from fn from(value: T) -> Self;
core::convert::Into::into fn into(self) -> T;
core::convert::TryFrom::try_from fn try_from(value: T) -> Result<Self, Self::Error>;
core::convert::TryInto::try_into fn try_into(self) -> Result<T, Self::Error>;
core::default::Default::default fn default() -> Self;
core::hint::unreachable_uncheckedpub const unsafe fn unreachable_unchecked() -> ! {
ub_checks::assert_unsafe_precondition!(
check_language_ub,
"hint::unreachable_unchecked must never be reached",
() => false
);
// SAFETY: the safety contract for `intrinsics::unreachable` must
// be upheld by the caller.
unsafe { intrinsics::unreachable() }
}
core::intrinsics::abortpub fn abort() -> !;
core::intrinsics::aggregate_raw_ptrpub const fn aggregate_raw_ptr<P: bounds::BuiltinDeref, D, M>(data: D, meta: M) -> P
where
<P as bounds::BuiltinDeref>::Pointee: ptr::Pointee<Metadata = M>;
core::intrinsics::align_ofpub const fn align_of<T>() -> usize;
core::intrinsics::atomic_andpub unsafe fn atomic_and<T: Copy, U: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: U) -> T;
core::intrinsics::atomic_cxchgpub unsafe fn atomic_cxchg<
T: Copy,
const ORD_SUCC: AtomicOrdering,
const ORD_FAIL: AtomicOrdering,
>(
dst: *mut T,
old: T,
src: T,
) -> (T, bool);
core::intrinsics::atomic_cxchgweakpub unsafe fn atomic_cxchgweak<
T: Copy,
const ORD_SUCC: AtomicOrdering,
const ORD_FAIL: AtomicOrdering,
>(
_dst: *mut T,
_old: T,
_src: T,
) -> (T, bool);
core::intrinsics::atomic_loadpub unsafe fn atomic_load<T: Copy, const ORD: AtomicOrdering>(src: *const T) -> T;
core::intrinsics::atomic_nandpub unsafe fn atomic_nand<T: Copy, U: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: U) -> T;
core::intrinsics::atomic_orpub unsafe fn atomic_or<T: Copy, U: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: U) -> T;
core::intrinsics::atomic_storepub unsafe fn atomic_store<T: Copy, const ORD: AtomicOrdering>(dst: *mut T, val: T);
core::intrinsics::atomic_umaxpub unsafe fn atomic_umax<T: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: T) -> T;
core::intrinsics::atomic_uminpub unsafe fn atomic_umin<T: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: T) -> T;
core::intrinsics::atomic_xaddpub unsafe fn atomic_xadd<T: Copy, U: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: U) -> T;
core::intrinsics::atomic_xchgpub unsafe fn atomic_xchg<T: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: T) -> T;
core::intrinsics::atomic_xorpub unsafe fn atomic_xor<T: Copy, U: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: U) -> T;
core::intrinsics::atomic_xsubpub unsafe fn atomic_xsub<T: Copy, U: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: U) -> T;
core::intrinsics::autodiffpub const fn autodiff<F, G, T: crate::marker::Tuple, R>(f: F, df: G, args: T) -> R;
core::intrinsics::const_eval_selectpub const fn const_eval_select<ARG: Tuple, F, G, RET>(
_arg: ARG,
_called_in_const: F,
_called_at_rt: G,
) -> RET
where
G: FnOnce<ARG, Output = RET>,
F: const FnOnce<ARG, Output = RET>;
core::intrinsics::const_make_globalpub const unsafe fn const_make_global(ptr: *mut u8) -> *const u8 {
// const eval overrides this function; at runtime, it is a NOP.
ptr
}
core::intrinsics::ctpoppub const fn ctpop<T: Copy>(x: T) -> u32;
core::intrinsics::discriminant_valuepub const fn discriminant_value<T>(v: &T) -> <T as DiscriminantKind>::Discriminant;
core::intrinsics::read_via_copypub const unsafe fn read_via_copy<T>(ptr: *const T) -> T;
core::intrinsics::size_ofpub const fn size_of<T>() -> usize;
core::intrinsics::three_way_comparepub const fn three_way_compare<T: Copy>(lhs: T, rhss: T) -> crate::cmp::Ordering;
core::intrinsics::transmutepub const unsafe fn transmute<Src, Dst>(src: Src) -> Dst;
core::intrinsics::ub_checkspub const fn ub_checks() -> bool {
cfg!(ub_checks)
}
core::intrinsics::unchecked_subpub const unsafe fn unchecked_sub<T: Copy>(x: T, y: T) -> T;
core::intrinsics::unreachablepub const unsafe fn unreachable() -> !;
core::intrinsics::write_via_movepub const unsafe fn write_via_move<T>(ptr: *mut T, value: T);
core::iter::traits::collect::IntoIterator::into_iter fn into_iter(self) -> Self::IntoIter;
core::iter::traits::iterator::Iterator::next fn next(&mut self) -> Option<Self::Item>;
core::ops::arith::Add::add fn add(self, rhs: Rhs) -> Self::Output;
core::ops::arith::AddAssign::add_assign fn add_assign(&mut self, rhs: Rhs);
core::ops::arith::Div::div fn div(self, rhs: Rhs) -> Self::Output;
core::ops::arith::DivAssign::div_assign fn div_assign(&mut self, rhs: Rhs);
core::ops::arith::Mul::mul fn mul(self, rhs: Rhs) -> Self::Output;
core::ops::arith::MulAssign::mul_assign fn mul_assign(&mut self, rhs: Rhs);
core::ops::arith::Neg::neg fn neg(self) -> Self::Output;
core::ops::arith::Rem::rem fn rem(self, rhs: Rhs) -> Self::Output;
core::ops::arith::RemAssign::rem_assign fn rem_assign(&mut self, rhs: Rhs);
core::ops::arith::Sub::sub fn sub(self, rhs: Rhs) -> Self::Output;
core::ops::arith::SubAssign::sub_assign fn sub_assign(&mut self, rhs: Rhs);
core::ops::bit::BitAnd::bitand fn bitand(self, rhs: Rhs) -> Self::Output;
core::ops::bit::BitAndAssign::bitand_assign fn bitand_assign(&mut self, rhs: Rhs);
core::ops::bit::BitOr::bitor fn bitor(self, rhs: Rhs) -> Self::Output;
core::ops::bit::BitOrAssign::bitor_assign fn bitor_assign(&mut self, rhs: Rhs);
core::ops::bit::BitXor::bitxor fn bitxor(self, rhs: Rhs) -> Self::Output;
core::ops::bit::BitXorAssign::bitxor_assign fn bitxor_assign(&mut self, rhs: Rhs);
core::ops::bit::Not::not fn not(self) -> Self::Output;
core::ops::bit::Shl::shl fn shl(self, rhs: Rhs) -> Self::Output;
core::ops::bit::ShlAssign::shl_assign fn shl_assign(&mut self, rhs: Rhs);
core::ops::bit::Shr::shr fn shr(self, rhs: Rhs) -> Self::Output;
core::ops::bit::ShrAssign::shr_assign fn shr_assign(&mut self, rhs: Rhs);
core::ops::deref::Deref::deref fn deref(&self) -> &Self::Target;
core::ops::deref::DerefMut::deref_mut fn deref_mut(&mut self) -> &mut Self::Target;
core::ops::function::Fn::call extern "rust-call" fn call(&self, args: Args) -> Self::Output;
core::ops::function::FnMut::call_mut extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
core::ops::function::FnOnce::call_once extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &F>::call_once extern "rust-call" fn call_once(self, args: A) -> F::Output {
(*self).call(args)
}
core::ops::range::IntoBounds::into_bounds fn into_bounds(self) -> (Bound<T>, Bound<T>);
core::ops::range::OneSidedRange::bound fn bound(self) -> (OneSidedRangeBound, T);
core::ops::range::RangeBounds::end_bound fn end_bound(&self) -> Bound<&T>;
core::ops::range::RangeBounds::start_bound fn start_bound(&self) -> Bound<&T>;
core::ops::try_trait::FromResidual::from_residual fn from_residual(residual: R) -> Self;
core::ops::try_trait::Try::branch fn branch(self) -> ControlFlow<Self::Residual, Self::Output>;
core::ops::try_trait::Try::from_output fn from_output(output: Self::Output) -> Self;
core::panicking::panicpub const fn panic(expr: &'static str) -> ! {
// Use Arguments::new_const instead of format_args!("{expr}") to potentially
// reduce size overhead. The format_args! macro uses str's Display trait to
// write expr, which calls Formatter::pad, which must accommodate string
// truncation and padding (even though none is used here). Using
// Arguments::new_const may allow the compiler to omit Formatter::pad from the
// output binary, saving up to a few kilobytes.
// However, this optimization only works for `'static` strings: `new_const` also makes this
// message return `Some` from `Arguments::as_str`, which means it can become part of the panic
// payload without any allocation or copying. Shorter-lived strings would become invalid as
// stack frames get popped during unwinding, and couldn't be directly referenced from the
// payload.
#[cfg(not(feature = "ferrocene_certified"))]
panic_fmt(fmt::Arguments::new_const(&[expr]));
#[cfg(feature = "ferrocene_certified")]
panic_fmt(&expr)
}
core::panicking::panic_cannot_unwindfn panic_cannot_unwind() -> ! {
// Keep the text in sync with `UnwindTerminateReason::as_str` in `rustc_middle`.
panic_nounwind("panic in a function that cannot unwind")
}
core::panicking::panic_fmtpub const fn panic_fmt(fmt: PanicFmt<'_>) -> ! {
// Ferrocene annotation: The `immediate-abort` behavior is not certified, we only support
// `abort`.
if cfg!(panic = "immediate-abort") {
super::intrinsics::abort()
}
// NOTE This function never crosses the FFI boundary; it's a Rust-to-Rust call
// that gets resolved to the `#[panic_handler]` function.
unsafe extern "Rust" {
#[lang = "panic_impl"]
fn panic_impl(pi: &PanicInfo<'_>) -> !;
}
#[cfg(not(feature = "ferrocene_certified"))]
let pi = PanicInfo::new(
&fmt,
Location::caller(),
/* can_unwind */ true,
/* force_no_backtrace */ false,
);
#[cfg(feature = "ferrocene_certified")]
let pi = PanicInfo::new(&fmt);
// SAFETY: `panic_impl` is defined in safe Rust code and thus is safe to call.
unsafe { panic_impl(&pi) }
}
core::panicking::panic_fmt::panic_impl fn panic_impl(pi: &PanicInfo<'_>) -> !;
core::panicking::panic_nounwindpub const fn panic_nounwind(expr: &'static str) -> ! {
#[cfg(not(feature = "ferrocene_certified"))]
panic_nounwind_fmt(fmt::Arguments::new_const(&[expr]), /* force_no_backtrace */ false);
#[cfg(feature = "ferrocene_certified")]
panic_nounwind_fmt(&expr, /* force_no_backtrace */ false);
}
core::panicking::panic_nounwind_fmtpub const fn panic_nounwind_fmt(fmt: PanicFmt<'_>, _force_no_backtrace: bool) -> ! {
const_eval_select!(
@capture { fmt: PanicFmt<'_>, _force_no_backtrace: bool } -> !:
if const #[track_caller] {
// We don't unwind anyway at compile-time so we can call the regular `panic_fmt`.
panic_fmt(fmt)
} else #[track_caller] {
if cfg!(panic = "immediate-abort") {
super::intrinsics::abort()
}
// NOTE This function never crosses the FFI boundary; it's a Rust-to-Rust call
// that gets resolved to the `#[panic_handler]` function.
unsafe extern "Rust" {
#[lang = "panic_impl"]
fn panic_impl(pi: &PanicInfo<'_>) -> !;
}
// PanicInfo with the `can_unwind` flag set to false forces an abort.
#[cfg(not(feature = "ferrocene_certified"))]
let pi = PanicInfo::new(
&fmt,
Location::caller(),
/* can_unwind */ false,
_force_no_backtrace,
);
#[cfg(feature = "ferrocene_certified")]
let pi = PanicInfo::new(&fmt);
// SAFETY: `panic_impl` is defined in safe Rust code and thus is safe to call.
unsafe { panic_impl(&pi) }
}
)
}
core::panicking::panic_nounwind_fmt::compiletime const fn compiletime$(<$($binders)*>)?($($arg: $ty),*) $( -> $ret )? {
// Don't warn if one of the arguments is unused.
$(let _ = $arg;)*
$compiletime
}
core::panicking::panic_nounwind_fmt::runtime::panic_impl fn panic_impl(pi: &PanicInfo<'_>) -> !;
core::ptr::const_ptr::<impl *const T>::is_null::compiletime const fn compiletime$(<$($binders)*>)?($($arg: $ty),*) $( -> $ret )? {
// Don't warn if one of the arguments is unused.
$(let _ = $arg;)*
$compiletime
}
core::ub_checks::check_language_ub::compiletime const fn compiletime$(<$($binders)*>)?($($arg: $ty),*) $( -> $ret )? {
// Don't warn if one of the arguments is unused.
$(let _ = $arg;)*
$compiletime
}
core::ub_checks::maybe_is_aligned::compiletime const fn compiletime$(<$($binders)*>)?($($arg: $ty),*) $( -> $ret )? {
// Don't warn if one of the arguments is unused.
$(let _ = $arg;)*
$compiletime
}