// codesnip-guard: floor_sum
#[cfg_attr(any(),rustfmt::skip)]pub use self::floor_sum::{floor_power_sum,floor_sum,floor_sum_i64,floor_sum_polynomial,floor_sum_polynomial_i64,floor_sum_range_freq,min_of_mod_of_linear};#[cfg_attr(any(),rustfmt::skip)]mod floor_sum{use super::{AddMulOperation,Associative,BarrettReduction,DotProduct,Group,Invertible,Magma,Monoid,One,Ring,SemiRing,Unital,Wrapping,array};use std::{marker::PhantomData,mem::swap,ops::Range};fn choose2(n:Wrapping<u64>)->Wrapping<u64>{if n.0 .is_multiple_of(2){n/2*(n-1)}else{(n-1)/2*n}}#[doc=" Sum of Floor of Linear mod 2^64"]#[doc=""]#[doc=" $$\\sum_{i=0}^{n-1}\\left\\lfloor\\frac{a\\times i+b}{m}\\right\\rfloor$$"]pub fn floor_sum(n:u64,a:u64,b:u64,m:u64)->u64{let mut ans=Wrapping(0u64);let(mut n,mut m,mut a,mut b)=(Wrapping(n),m,a,b);loop{let br=BarrettReduction::<u64>::new(m);if a>=m{let(q,r)=br.div_rem(a);ans+=choose2(n)*q;a=r;}if b>=m{let(q,r)=br.div_rem(b);ans+=n*q;b=r;}let(q,r)=if let Some(y_max)=n.0 .checked_mul(a).and_then(|x|x.checked_add(b)){if y_max<m{break;}br.div_rem(y_max)}else{let y_max=n.0 as u128*a as u128+b as u128;((y_max/m as u128)as u64,(y_max%m as u128)as u64)};n=Wrapping(q);b=r;swap(&mut m,&mut a);}ans.0}#[doc=" $$\\min(\\{(a\\times i+b)\\bmod m\\mid0\\leq i<n\\}\\cup\\{m\\})$$"]pub fn min_of_mod_of_linear(mut n:u64,mut a:u64,mut b:u64,mut m:u64)->u64{if n==0{return m;}if a>=m{a%=m;}if b>=m{b%=m;}let mut ans=Wrapping(0u64);let mut pos=true;let mut p=1;let mut q=1;while a!=0{let e=if pos{a}else{m}-1;let r=m%a;let d=m-b;if if pos{b+1}else{d}>a{let t=(d-1)/a+u64::from(pos);let c=(t-u64::from(pos))*p+if pos{q}else{0};if n<=c{if!pos{ans-=Wrapping(a)*Wrapping((n-1)/p);}break;}n-=c;if pos{b=a*t-d;}else{b+=a*t;}}if r!=0{let x=m/a*p+q;q=x;p=x-p;}if pos{ans+=e;}else{ans-=e;}m=a;a=r;b=e-b;pos=!pos;}if pos{(ans+b).0}else{(ans-b).0}}#[doc=" Sum of Floor of Linear mod 2^64"]#[doc=""]#[doc=" $$\\sum_{i=l}^{r-1}\\left\\lfloor\\frac{a\\times i+b}{m}\\right\\rfloor$$"]pub fn floor_sum_i64(l:i64,r:i64,a:i64,b:i64,m:u64)->i64{let mut ans=Wrapping(0i64);let(n,m,a,b)=(Wrapping((r-l)as u64),m as i64,a,(Wrapping(l)*a+b).0);let a=if a<0{let r=a.rem_euclid(m);let nc2=choose2(n);ans-=Wrapping(nc2.0 as _)*((Wrapping(r)-a)/m);r}else{a};let b=if b<0{let r=b.rem_euclid(m);ans-=Wrapping(n.0 as _)*((Wrapping(r)-b)/m);r}else{b};(ans+floor_sum(n.0,a as u64,b as u64,m as u64)as i64).0}pub fn floor_sum_range_freq(l:i64,r:i64,a:i64,b:i64,m:u64,range:Range<i64>)->i64{if range.start>=range.end{return 0;}assert!(0<=range.start&&range.end<=m as i64);let x1=floor_sum_i64(l,r,a,b-range.start,m);let x2=floor_sum_i64(l,r,a,b-range.end,m);x1-x2}struct FloorSum<R,const X:usize,const Y:usize>where R:SemiRing{_marker:PhantomData<fn()->R>}#[derive(Debug)]struct FloorSumData<R,const X:usize,const Y:usize>where R:SemiRing{dp:[[R::T;Y];X],dx:R::T,dy:R::T,_marker:PhantomData<fn()->R>}impl<R,const X:usize,const Y:usize>Clone for FloorSumData<R,X,Y>where R:SemiRing{fn clone(&self)->Self{Self{dp:self.dp.clone(),dx:self.dx.clone(),dy:self.dy.clone(),_marker:self._marker}}}impl<R,const X:usize,const Y:usize>FloorSum<R,X,Y>where R:SemiRing{fn to_x()->FloorSumData<R,X,Y>{let mut dp=array![array![R::zero();Y];X];dp[0][0]=R::one();FloorSumData{dp,dx:R::one(),dy:R::zero(),_marker:PhantomData}}fn to_y()->FloorSumData<R,X,Y>{FloorSumData{dp:array![array![R::zero();Y];X],dx:R::zero(),dy:R::one(),_marker:PhantomData}}}impl<R,const X:usize,const Y:usize>FloorSum<R,X,Y>where R:Ring<Additive:Invertible>{fn offset(x:i64,y:i64)->FloorSumData<R,X,Y>{FloorSumData{dp:array![array![R::zero();Y];X],dx:R::Additive::signed_pow(R::one(),x),dy:R::Additive::signed_pow(R::one(),y),_marker:PhantomData}}}impl<R,const X:usize,const Y:usize>Magma for FloorSum<R,X,Y>where R:SemiRing{type T=FloorSumData<R,X,Y>;fn operate(a:&Self::T,b:&Self::T)->Self::T{let mut a=a.clone();let mut b=b.clone();let mut pow_x=array![R::zero();X];let mut pow_y=array![R::zero();Y];pow_x[0]=R::one();pow_y[0]=R::one();for i in 1..X{pow_x[i]=R::mul(&pow_x[i-1],&a.dx);}for j in 1..Y{pow_y[j]=R::mul(&pow_y[j-1],&a.dy);}macro_rules!go{($N:ident)=>{let mut comb=array![array![R::zero();$N];$N];comb[0][0]=R::one();let mut i=0;while i+1<$N{let mut j=0;while j<=i{let x=comb[i][j].clone();R::add_assign(&mut comb[i+1][j],&x);R::add_assign(&mut comb[i+1][j+1],&x);j+=1;}i+=1;}for i in 0..X{for j in(0..Y).rev(){for k in j+1..Y{let mut x=b.dp[i][j].clone();R::mul_assign(&mut x,&comb[k][j]);R::mul_assign(&mut x,&pow_y[k-j]);R::add_assign(&mut b.dp[i][k],&x);}}}for j in 0..Y{for i in(0..X).rev(){for k in i..X{let mut x=b.dp[i][j].clone();R::mul_assign(&mut x,&comb[k][i]);R::mul_assign(&mut x,&pow_x[k-i]);R::add_assign(&mut a.dp[k][j],&x);}}}};}if X<=Y{go!(Y);}else{go!(X);}R::add_assign(&mut a.dx,&b.dx);R::add_assign(&mut a.dy,&b.dy);a}}impl<R,const X:usize,const Y:usize>Unital for FloorSum<R,X,Y>where R:SemiRing{fn unit()->Self::T{FloorSumData{dp:array![array![R::zero();Y];X],dx:R::zero(),dy:R::zero(),_marker:PhantomData}}}impl<R,const X:usize,const Y:usize>Associative for FloorSum<R,X,Y>where R:SemiRing{}fn floor_monoid_product<M>(mut x:M::T,mut y:M::T,mut n:u64,mut a:u64,mut b:u64,mut m:u64)->M::T where M:Monoid{let mut c=(a*n+b)/m;let mut pre=M::unit();let mut suf=M::unit();loop{let(p,q)=(a/m,b/m);a%=m;b%=m;x=M::operate(&x,&M::pow(y.clone(),p));pre=M::operate(&pre,&M::pow(y.clone(),q));c-=p*n+q;if c==0{break;}let d=(m*c-b-1)/a+1;suf=M::operate(&y,&M::operate(&M::pow(x.clone(),n-d),&suf));b=m-b-1+a;n=c-1;c=d;swap(&mut m,&mut a);swap(&mut x,&mut y);}x=M::pow(x.clone(),n);M::operate(&M::operate(&pre,&x),&suf)}#[doc=" $$\\sum_{i=0}^{n-1}i^X\\left\\lfloor\\frac{a\\times i+b}{m}\\right\\rfloor^Y$$"]pub fn floor_sum_polynomial<T,const X:usize,const Y:usize>(n:u64,a:u64,b:u64,m:u64)->[[T;Y];X]where T:DotProduct+One{debug_assert!(a==0||n<(u64::MAX-b)/a);floor_monoid_product::<FloorSum<AddMulOperation<T>,X,Y>>(FloorSum::<AddMulOperation<T>,X,Y>::to_x(),FloorSum::<AddMulOperation<T>,X,Y>::to_y(),n,a,b,m).dp}#[doc=" $$\\sum_{i=l}^{r-1}i^X\\left\\lfloor\\frac{a\\times i+b}{m}\\right\\rfloor^Y$$"]pub fn floor_sum_polynomial_i64<T,const X:usize,const Y:usize>(l:i64,r:i64,a:i64,b:i64,m:u64)->[[T;Y];X]where T:DotProduct+One,AddMulOperation<T>:SemiRing<T=T,Additive:Invertible>{assert!(l<=r);assert!(m>0);if a<0{let mut ans=floor_sum_polynomial_i64::<T,X,Y>(-r+1,-l+1,-a,b,m);for ans in ans.iter_mut().skip(1).step_by(2){for ans in ans.iter_mut(){*ans=AddMulOperation::<T>::neg(ans);}}return ans;}let add_x=l;let n=(r-l)as u64;let b=a*add_x+b;let add_y=b.div_euclid(m as i64);let b=b.rem_euclid(m as i64);assert!(a>=0);assert!(b>=0);let data=floor_monoid_product::<FloorSum<AddMulOperation<T>,X,Y>>(FloorSum::<AddMulOperation<T>,X,Y>::to_x(),FloorSum::<AddMulOperation<T>,X,Y>::to_y(),n,a as u64,b as u64,m);let offset=FloorSum::<AddMulOperation<T>,X,Y>::offset(add_x,add_y);FloorSum::<AddMulOperation<T>,X,Y>::operate(&offset,&data).dp}#[derive(Debug)]struct FloorPowerSum<R>where R:SemiRing{x:R::T,sum:R::T}impl<R>Clone for FloorPowerSum<R>where R:SemiRing{fn clone(&self)->Self{Self{x:self.x.clone(),sum:self.sum.clone()}}}impl<R>FloorPowerSum<R>where R:SemiRing{fn to_x(x:R::T)->Self{Self{x,sum:R::one()}}fn to_y(y:R::T)->Self{Self{x:y,sum:R::zero()}}}impl<R>Magma for FloorPowerSum<R>where R:SemiRing{type T=Self;fn operate(a:&Self::T,b:&Self::T)->Self::T{Self{x:R::mul(&a.x,&b.x),sum:R::add(&a.sum,&R::mul(&a.x,&b.sum))}}}impl<R>Unital for FloorPowerSum<R>where R:SemiRing{fn unit()->Self::T{Self{x:R::one(),sum:R::zero()}}}impl<R>Associative for FloorPowerSum<R>where R:SemiRing{}#[doc=" $$\\sum_{i=0}^{n-1}x^iy^{\\left\\lfloor\\frac{a\\times i+b}{m}\\right\\rfloor}$$"]pub fn floor_power_sum<R>(x:R::T,y:R::T,n:u64,a:u64,b:u64,m:u64)->R::T where R:SemiRing{floor_monoid_product::<FloorPowerSum<R>>(FloorPowerSum::<R>::to_x(x),FloorPowerSum::<R>::to_y(y),n,a,b,m).sum}}
// codesnip-guard: AdditiveOperation
#[cfg_attr(any(),rustfmt::skip)]pub use self::additive_operation_impl::AdditiveOperation;#[cfg_attr(any(),rustfmt::skip)]mod additive_operation_impl{use super::*;use std::{marker::PhantomData,ops::{Add,Neg,Sub}};#[doc=" $+$"]pub struct AdditiveOperation<T>where T:Clone+Zero+Add<Output=T>{_marker:PhantomData<fn()->T>}impl<T>Magma for AdditiveOperation<T>where T:Clone+Zero+Add<Output=T>{type T=T;#[inline]fn operate(x:&Self::T,y:&Self::T)->Self::T{x.clone()+y.clone()}}impl<T>Unital for AdditiveOperation<T>where T:Clone+Zero+Add<Output=T>{#[inline]fn unit()->Self::T{Zero::zero()}}impl<T>Associative for AdditiveOperation<T>where T:Clone+Zero+Add<Output=T>{}impl<T>Commutative for AdditiveOperation<T>where T:Clone+Zero+Add<Output=T>{}impl<T>Invertible for AdditiveOperation<T>where T:Clone+Zero+Add<Output=T>+Sub<Output=T>+Neg<Output=T>{#[inline]fn inverse(x:&Self::T)->Self::T{-x.clone()}#[inline]fn rinv_operate(x:&Self::T,y:&Self::T)->Self::T{x.clone()-y.clone()}}}
// codesnip-guard: BarrettReduction
#[cfg_attr(any(),rustfmt::skip)]pub use self::barrett_reduction::{BarrettReduction,Barrettable};#[cfg_attr(any(),rustfmt::skip)]mod barrett_reduction{use super::{One,Zero};use std::ops::{Add,Mul,Sub};#[derive(Debug,Clone,Copy)]pub struct BarrettReduction<T>{m:T,im:T}impl<T>BarrettReduction<T>where T:Barrettable{pub fn new(m:T)->Self{Self{m,im:T::inv_mod_approx(m)}}pub const fn new_with_im(m:T,im:T)->Self{Self{m,im}}pub const fn get_mod(&self)->T{self.m}pub fn div_rem(&self,a:T)->(T,T){T::barrett_reduce(a,self.m,self.im)}pub fn div(&self,a:T)->T{self.div_rem(a).0}pub fn rem(&self,a:T)->T{self.div_rem(a).1}}pub trait Barrettable:Sized+Copy+PartialOrd+Zero+One+Add<Output=Self>+Sub<Output=Self>+Mul<Output=Self>{fn inv_mod_approx(m:Self)->Self;fn div_approx(self,im:Self)->Self;fn barrett_reduce(self,m:Self,im:Self)->(Self,Self){if m==Self::one(){return(self,Self::zero());}let q=self.div_approx(im);let r=self-q*m;if m<=r{(q+Self::one(),r-m)}else{(q,r)}}}impl Barrettable for u32{fn inv_mod_approx(m:Self)->Self{!0/m}fn div_approx(self,im:Self)->Self{((self as u64*im as u64)>>32)as u32}}impl Barrettable for u64{fn inv_mod_approx(m:Self)->Self{!0/m}fn div_approx(self,im:Self)->Self{((self as u128*im as u128)>>64)as u64}}impl Barrettable for u128{fn inv_mod_approx(m:Self)->Self{!0/m}fn div_approx(self,im:Self)->Self{const MASK64:u128=0xffff_ffff_ffff_ffff;let au=self>>64;let ad=self&MASK64;let imu=im>>64;let imd=im&MASK64;let res=au*imu;let x=((ad*imd)>>64)+au*imd;let(x,c)=x.overflowing_add(ad*imu);res+((c as u128)<<64)+(x>>64)}}}
// codesnip-guard: MultiplicativeOperation
#[cfg_attr(any(),rustfmt::skip)]pub use self::multiplicative_operation_impl::MultiplicativeOperation;#[cfg_attr(any(),rustfmt::skip)]mod multiplicative_operation_impl{use super::*;use std::{marker::PhantomData,ops::{Div,Mul}};#[doc=" $\\times$"]pub struct MultiplicativeOperation<T>where T:Clone+One+Mul<Output=T>{_marker:PhantomData<fn()->T>}impl<T>Magma for MultiplicativeOperation<T>where T:Clone+One+Mul<Output=T>{type T=T;#[inline]fn operate(x:&Self::T,y:&Self::T)->Self::T{x.clone()*y.clone()}}impl<T>Unital for MultiplicativeOperation<T>where T:Clone+One+Mul<Output=T>{#[inline]fn unit()->Self::T{One::one()}}impl<T>Associative for MultiplicativeOperation<T>where T:Clone+One+Mul<Output=T>{}impl<T>Commutative for MultiplicativeOperation<T>where T:Clone+One+Mul<Output=T>{}impl<T>Invertible for MultiplicativeOperation<T>where T:Clone+One+Mul<Output=T>+Div<Output=T>{#[inline]fn inverse(x:&Self::T)->Self::T{Self::unit().div(x.clone())}#[inline]fn rinv_operate(x:&Self::T,y:&Self::T)->Self::T{(x.clone()).div(y.clone())}}}
// codesnip-guard: algebra
#[cfg_attr(any(),rustfmt::skip)]pub use self::magma::*;#[cfg_attr(any(),rustfmt::skip)]mod magma{#![doc=" algebraic traits"]#[doc=" binary operaion: $T \\circ T \\to T$"]pub trait Magma{#[doc=" type of operands: $T$"]type T:Clone;#[doc=" binary operaion: $\\circ$"]fn operate(x:&Self::T,y:&Self::T)->Self::T;fn reverse_operate(x:&Self::T,y:&Self::T)->Self::T{Self::operate(y,x)}fn operate_assign(x:&mut Self::T,y:&Self::T){*x=Self::operate(x,y);}}#[doc=" $\\forall a,\\forall b,\\forall c \\in T, (a \\circ b) \\circ c = a \\circ (b \\circ c)$"]pub trait Associative:Magma{}#[doc=" associative binary operation"]pub trait SemiGroup:Magma+Associative{}impl<S>SemiGroup for S where S:Magma+Associative{}#[doc=" $\\exists e \\in T, \\forall a \\in T, e \\circ a = a \\circ e = a$"]pub trait Unital:Magma{#[doc=" identity element: $e$"]fn unit()->Self::T;fn is_unit(x:&Self::T)->bool where Self::T:PartialEq{x==&Self::unit()}fn set_unit(x:&mut Self::T){*x=Self::unit();}}pub trait ExpBits{type Iter:Iterator<Item=bool>;fn bits(self)->Self::Iter;}pub trait SignedExpBits{type T:ExpBits;fn neg_and_bits(self)->(bool,Self::T);}pub struct Bits<T>{n:T}macro_rules!impl_exp_bits_for_uint{($($t:ty)*)=>{$(impl Iterator for Bits<$t>{type Item=bool;fn next(&mut self)->Option<bool>{if self.n==0{None}else{let bit=(self.n&1)==1;self.n>>=1;Some(bit)}}}impl ExpBits for$t{type Iter=Bits<$t>;fn bits(self)->Self::Iter{Bits{n:self}}}impl SignedExpBits for$t{type T=$t;fn neg_and_bits(self)->(bool,Self::T){(false,self)}})*};}impl_exp_bits_for_uint!(u8 u16 u32 u64 u128 usize);macro_rules!impl_signed_exp_bits_for_sint{($($s:ty,$u:ty;)*)=>{$(impl SignedExpBits for$s{type T=$u;fn neg_and_bits(self)->(bool,Self::T){(self<0,self.unsigned_abs())}})*};}impl_signed_exp_bits_for_sint!(i8,u8;i16,u16;i32,u32;i64,u64;i128,u128;isize,usize;);#[doc=" associative binary operation and an identity element"]pub trait Monoid:SemiGroup+Unital{#[doc=" binary exponentiation: $x^n = x\\circ\\ddots\\circ x$"]fn pow<E>(mut x:Self::T,exp:E)->Self::T where E:ExpBits{let mut bits=exp.bits();let Some(first)=bits.next()else{return Self::unit();};let mut res=if first{x.clone()}else{Self::unit()};for bit in bits{x=Self::operate(&x,&x);if bit{res=Self::operate(&res,&x);}}res}fn fold<I>(iter:I)->Self::T where I:IntoIterator<Item=Self::T>{let mut iter=iter.into_iter();if let Some(item)=iter.next(){iter.fold(item,|acc,x|Self::operate(&acc,&x))}else{Self::unit()}}}impl<M>Monoid for M where M:SemiGroup+Unital{}#[doc=" $\\exists e \\in T, \\forall a \\in T, \\exists b,c \\in T, b \\circ a = a \\circ c = e$"]pub trait Invertible:Magma+Unital{#[doc=" $a$ where $a \\circ x = e$"]fn inverse(x:&Self::T)->Self::T;fn rinv_operate(x:&Self::T,y:&Self::T)->Self::T{Self::operate(x,&Self::inverse(y))}fn rinv_operate_assign(x:&mut Self::T,y:&Self::T){*x=Self::rinv_operate(x,y);}}#[doc=" associative binary operation and an identity element and inverse elements"]pub trait Group:Monoid+Invertible{fn signed_pow<E>(x:Self::T,exp:E)->Self::T where E:SignedExpBits{let(neg,exp)=E::neg_and_bits(exp);let res=Self::pow(x,exp);if neg{Self::inverse(&res)}else{res}}}impl<G>Group for G where G:Monoid+Invertible{}#[doc=" $\\forall a,\\forall b \\in T, a \\circ b = b \\circ a$"]pub trait Commutative:Magma{}#[doc=" commutative monoid"]pub trait AbelianMonoid:Monoid+Commutative{}impl<M>AbelianMonoid for M where M:Monoid+Commutative{}#[doc=" commutative group"]pub trait AbelianGroup:Group+Commutative{}impl<G>AbelianGroup for G where G:Group+Commutative{}#[doc=" $\\forall a \\in T, a \\circ a = a$"]pub trait Idempotent:Magma{}#[doc=" idempotent monoid"]pub trait IdempotentMonoid:Monoid+Idempotent{}impl<M>IdempotentMonoid for M where M:Monoid+Idempotent{}#[macro_export]macro_rules!monoid_fold{($m:ty)=>{<$m as Unital>::unit()};($m:ty,)=>{<$m as Unital>::unit()};($m:ty,$f:expr)=>{$f};($m:ty,$f:expr,$($ff:expr),*)=>{<$m as Magma>::operate(&($f),&monoid_fold!($m,$($ff),*))};}#[macro_export]macro_rules!define_monoid{($Name:ident,$t:ty,|$x:ident,$y:ident|$op:expr,$unit:expr)=>{struct$Name;impl Magma for$Name{type T=$t;fn operate($x:&Self::T,$y:&Self::T)->Self::T{$op}}impl Unital for$Name{fn unit()->Self::T{$unit}}impl Associative for$Name{}};}}
// codesnip-guard: array
#[cfg_attr(any(),rustfmt::skip)]mod array{#[macro_export]macro_rules!array{[@inner$data:ident=[$init:expr;$len:expr]]=>{{use::std::mem::{ManuallyDrop,MaybeUninit};let mut$data:[MaybeUninit<_>;$len]=unsafe{MaybeUninit::uninit().assume_init()};$init;#[repr(C)]union __Transmuter<const N:usize,T:Clone>{src:ManuallyDrop<[MaybeUninit<T>;N]>,dst:ManuallyDrop<[T;N]>,}ManuallyDrop::into_inner(unsafe{__Transmuter{src:ManuallyDrop::new($data)}.dst})}};[||$e:expr;$len:expr]=>{$crate::array![@inner data=[data.iter_mut().for_each(|item|*item=MaybeUninit::new($e));$len]]};[|$i:pat_param|$e:expr;$len:expr]=>{$crate::array![@inner data=[data.iter_mut().enumerate().for_each(|($i,item)|*item=MaybeUninit::new($e));$len]]};[$e:expr;$len:expr]=>{{let e=$e;$crate::array![||Clone::clone(&e);$len]}};}}
// codesnip-guard: bounded
#[cfg_attr(any(),rustfmt::skip)]pub use self::bounded::Bounded;#[cfg_attr(any(),rustfmt::skip)]mod bounded{#[doc=" Trait for max/min bounds"]pub trait Bounded:Sized+PartialOrd{fn maximum()->Self;fn minimum()->Self;fn is_maximum(&self)->bool{self==&Self::maximum()}fn is_minimum(&self)->bool{self==&Self::minimum()}fn set_maximum(&mut self){*self=Self::maximum()}fn set_minimum(&mut self){*self=Self::minimum()}}macro_rules!impl_bounded_num{($($t:ident)*)=>{$(impl Bounded for$t{fn maximum()->Self{$t::MAX}fn minimum()->Self{$t::MIN}})*};}impl_bounded_num!(u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize f32 f64);macro_rules!impl_bounded_tuple{(@impl$($T:ident)*)=>{impl<$($T:Bounded),*>Bounded for($($T,)*){fn maximum()->Self{($(<$T as Bounded>::maximum(),)*)}fn minimum()->Self{($(<$T as Bounded>::minimum(),)*)}}};(@inner$($T:ident)*,)=>{impl_bounded_tuple!(@impl$($T)*);};(@inner$($T:ident)*,$U:ident$($Rest:ident)*)=>{impl_bounded_tuple!(@impl$($T)*);impl_bounded_tuple!(@inner$($T)*$U,$($Rest)*);};($T:ident$($Rest:ident)*)=>{impl_bounded_tuple!(@inner$T,$($Rest)*);};}impl_bounded_tuple!(A B C D E F G H I J);impl Bounded for(){fn maximum()->Self{}fn minimum()->Self{}}impl Bounded for bool{fn maximum()->Self{true}fn minimum()->Self{false}}impl<T>Bounded for Option<T>where T:Bounded{fn maximum()->Self{Some(<T as Bounded>::maximum())}fn minimum()->Self{None}}impl<T>Bounded for std::cmp::Reverse<T>where T:Bounded{fn maximum()->Self{std::cmp::Reverse(<T as Bounded>::minimum())}fn minimum()->Self{std::cmp::Reverse(<T as Bounded>::maximum())}}}
// codesnip-guard: integer
#[cfg_attr(any(),rustfmt::skip)]pub use self::integer::{BinaryRepr,ExtendedGcd,IntBase,Saturating,Saturatingable,Signed,Unsigned,Wrapping,Wrappingable};#[cfg_attr(any(),rustfmt::skip)]mod integer{use super::{Bounded,One,Scan,ScanSource,Zero};use std::{convert::TryFrom,fmt::{self,Display},iter::{Product,Sum},ops::{Add,AddAssign,BitAnd,BitAndAssign,BitOr,BitOrAssign,BitXor,BitXorAssign,Div,DivAssign,Mul,MulAssign,Neg,Not,Rem,RemAssign,Shl,ShlAssign,Shr,ShrAssign,Sub,SubAssign},str::FromStr};#[doc=" Trait for basic primitive integer operations."]pub trait IntBase:Copy+Bounded+Zero+One+Eq+Ord+Default+FromStr+Display+Add<Output=Self>+Sub<Output=Self>+Mul<Output=Self>+Div<Output=Self>+Rem<Output=Self>+AddAssign+SubAssign+MulAssign+DivAssign+RemAssign+Sum+Product{type Error;fn div_euclid(self,rhs:Self)->Self;fn rem_euclid(self,rhs:Self)->Self;fn pow(self,exp:u32)->Self;fn from_str_radix(src:&str,radix:u32)->Result<Self,Self::Error>;fn ilog(self,base:Self)->u32;fn ilog2(self)->u32;fn ilog10(self)->u32;fn isqrt(self)->Self;fn midpoint(self,rhs:Self)->Self;}macro_rules!impl_int_base{($($t:ty)*)=>{$(impl IntBase for$t{type Error=std::num::ParseIntError;fn div_euclid(self,rhs:Self)->Self{self.div_euclid(rhs)}fn rem_euclid(self,rhs:Self)->Self{self.rem_euclid(rhs)}fn pow(self,exp:u32)->Self{self.pow(exp)}fn from_str_radix(src:&str,radix:u32)->Result<Self,Self::Error>{Self::from_str_radix(src,radix)}fn ilog(self,base:Self)->u32{self.ilog(base)}fn ilog2(self)->u32{self.ilog2()}fn ilog10(self)->u32{self.ilog10()}fn isqrt(self)->Self{self.isqrt()}fn midpoint(self,rhs:Self)->Self{self.midpoint(rhs)}})*};}impl_int_base!(u8 i8 u16 i16 u32 i32 u64 i64 u128 i128 usize isize);#[doc=" extended_gcd(a,b): ax + by = g = gcd(a,b)"]pub struct ExtendedGcd<T:Signed>{#[doc=" gcd"]pub g:T::Unsigned,pub x:T,pub y:T}#[doc=" Trait for unsigned integer operations."]pub trait Unsigned:IntBase{type Signed:Signed<Unsigned=Self>;fn signed(self)->Self::Signed;fn abs_diff(self,other:Self)->Self;fn div_ceil(self,rhs:Self)->Self;fn is_power_of_two(self)->bool;fn next_power_of_two(self)->Self;fn is_multiple_of(self,rhs:Self)->bool;fn next_multiple_of(self,rhs:Self)->Self;fn gcd(self,other:Self)->Self;fn lcm(self,other:Self)->Self{if self.is_zero()&&other.is_zero(){Self::zero()}else{self/self.gcd(other)*other}}fn mod_inv(self,modulo:Self)->Self{debug_assert!(!modulo.is_zero(),"modulo must be non-zero");if modulo.is_one(){return Self::zero();}let(mut a,mut b)=(self,modulo);let(mut u,mut v)=(Self::one(),Self::zero());let mut negative=true;while!a.is_zero(){let k=b/a;v+=k*u;b-=k*a;std::mem::swap(&mut u,&mut v);std::mem::swap(&mut b,&mut a);negative=!negative;}debug_assert!(b.is_one(),"not coprime");if negative{v.mod_neg(modulo)}else{v}}fn mod_add(self,rhs:Self,modulo:Self)->Self;fn mod_sub(self,rhs:Self,modulo:Self)->Self;fn mod_mul(self,rhs:Self,modulo:Self)->Self;fn mod_neg(self,modulo:Self)->Self{debug_assert!(!modulo.is_zero(),"modulo must be non-zero");debug_assert!(self<modulo,"self must be less than modulo");if self.is_zero(){Self::zero()}else{modulo-self}}}#[doc=" Trait for signed integer operations."]pub trait Signed:IntBase+Neg<Output=Self>{type Unsigned:Unsigned<Signed=Self>;fn unsigned(self)->Self::Unsigned;fn abs(self)->Self;fn abs_diff(self,other:Self)->Self::Unsigned;fn is_negative(self)->bool;fn is_positive(self)->bool;fn signum(self)->Self;fn extgcd(self,other:Self)->ExtendedGcd<Self>{let(mut a,mut b)=(self,other);let(mut u,mut v,mut x,mut y)=(Self::one(),Self::zero(),Self::zero(),Self::one());while!a.is_zero(){let k=b/a;x-=k*u;y-=k*v;b-=k*a;std::mem::swap(&mut x,&mut u);std::mem::swap(&mut y,&mut v);std::mem::swap(&mut b,&mut a);}if b.is_negative(){b=-b;x=-x;y=-y;}ExtendedGcd{g:b.unsigned(),x,y}}}macro_rules!impl_unsigned_signed{($([$($tt:tt)*])*)=>{$(impl_unsigned_signed!($($tt)*);)*};($unsigned:ident$signed:ident$upperty:ident)=>{impl_unsigned_signed!(@inner$unsigned$signed fn mod_mul(self,rhs:Self,modulo:Self)->Self{debug_assert!(!modulo.is_zero(),"modulo must be non-zero");(self as$upperty*rhs as$upperty%modulo as$upperty)as$unsigned});};(u128 i128)=>{impl_unsigned_signed!(@inner u128 i128 fn mod_mul(self,rhs:Self,modulo:Self)->Self{debug_assert!(!modulo.is_zero(),"modulo must be non-zero");const MASK64:u128=0xffff_ffff_ffff_ffff;let(au,ad)=(self>>64,self&MASK64);let(bu,bd)=(rhs>>64,rhs&MASK64);let p0=ad*bd%modulo;let p2=au*bu%modulo;let mut x=[p0 as u64,(p0>>64)as u64,p2 as u64,(p2>>64)as u64,];let p1=(au*bd%modulo).mod_add(ad*bu%modulo,modulo);let(p1_lo,p1_hi)=((p1&MASK64)as u64,(p1>>64)as u64);let(s1,c1)=x[1].overflowing_add(p1_lo);x[1]=s1 as u64;let(s2,c2)=x[2].overflowing_add(p1_hi+c1 as u64);x[2]=s2 as u64;let(s3,_)=x[3].overflowing_add(c2 as u64);x[3]=s3 as u64;rem_u256_by_u128(x,modulo)});};(@inner$unsigned:ident$signed:ident$mod_mul:item)=>{impl Unsigned for$unsigned{type Signed=$signed;fn signed(self)->Self::Signed{self as Self::Signed}fn abs_diff(self,other:Self)->Self{self.abs_diff(other)}fn div_ceil(self,rhs:Self)->Self{self.div_ceil(rhs)}fn is_power_of_two(self)->bool{self.is_power_of_two()}fn next_power_of_two(self)->Self{self.next_power_of_two()}fn is_multiple_of(self,rhs:Self)->bool{self.is_multiple_of(rhs)}fn next_multiple_of(self,rhs:Self)->Self{self.next_multiple_of(rhs)}fn gcd(self,other:Self)->Self{let(mut a,mut b)=(self,other);if a.is_zero()||b.is_zero(){return a|b;}let u=a.trailing_zeros();let v=b.trailing_zeros();a>>=u;b>>=v;let k=u.min(v);while a!=b{if a<b{std::mem::swap(&mut a,&mut b);}a-=b;a>>=a.trailing_zeros();}a<<k}fn mod_add(self,rhs:Self,modulo:Self)->Self{debug_assert!(!modulo.is_zero(),"modulo must be non-zero");debug_assert!(self<modulo,"self must be less than modulo");debug_assert!(rhs<modulo,"rhs must be less than modulo");let s=self.wrapping_add(rhs);if(s<self)||(s>=modulo){s.wrapping_sub(modulo)}else{s}}fn mod_sub(self,rhs:Self,modulo:Self)->Self{debug_assert!(!modulo.is_zero(),"modulo must be non-zero");debug_assert!(self<modulo,"self must be less than modulo");debug_assert!(rhs<modulo,"rhs must be less than modulo");let d=self.wrapping_sub(rhs);if self<rhs{d.wrapping_add(modulo)}else{d}}$mod_mul}impl Signed for$signed{type Unsigned=$unsigned;fn unsigned(self)->Self::Unsigned{self as Self::Unsigned}fn abs_diff(self,other:Self)->Self::Unsigned{self.abs_diff(other)}fn abs(self)->Self{self.abs()}fn is_negative(self)->bool{self.is_negative()}fn is_positive(self)->bool{self.is_positive()}fn signum(self)->Self{self.signum()}}};}impl_unsigned_signed!([u8 i8 u16][u16 i16 u32][u32 i32 u64][u64 i64 u128][u128 i128][usize isize u128]);fn rem_u256_by_u128(u:[u64;4],v:u128)->u128{#[inline(always)]fn sub_with_borrow_u64(lhs:u64,rhs:u64,borrow:bool)->(u64,bool){let(res,overflow)=lhs.overflowing_sub(rhs);if borrow{let(res,overflow_borrow)=res.overflowing_sub(1);(res,overflow|overflow_borrow)}else{(res,overflow)}}debug_assert!(v!=0);let v_hi=(v>>64)as u64;if v_hi==0{let d=v as u64 as u128;let mut rem:u128=0;for&w in u.iter().rev(){rem=(rem<<64|w as u128)%d;}return rem;}let v_lo=v as u64;let v_shift=v_hi.leading_zeros();let(vn1,vn0)=if v_shift==0{(v_hi,v_lo)}else{let hi=v_hi<<v_shift|v_lo>>(64-v_shift);let lo=v_lo<<v_shift;(hi,lo)};let mut un=[0u64;5];if v_shift==0{un[0]=u[0];un[1]=u[1];un[2]=u[2];un[3]=u[3];}else{un[0]=u[0]<<v_shift;un[1]=u[1]<<v_shift|u[0]>>(64-v_shift);un[2]=u[2]<<v_shift|u[1]>>(64-v_shift);un[3]=u[3]<<v_shift|u[2]>>(64-v_shift);un[4]=u[3]>>(64-v_shift);}for j in(0..=2).rev(){let num=(un[j+2]as u128)<<64|un[j+1]as u128;let(mut qhat,mut rhat)={let d=vn1 as u128;let q=(num/d).min(u64::MAX as u128);(q as u64,(num-q*d).min(u64::MAX as u128)as u64)};while qhat as u128*vn0 as u128>(rhat as u128)<<64|un[j]as u128{qhat-=1;let t=rhat as u128+vn1 as u128;if t>=1u128<<64{break;}rhat=t as u64;}let p0=qhat as u128*vn0 as u128;let p1=qhat as u128*vn1 as u128;let(p0_hi,p0_lo)=((p0>>64)as u64,p0 as u64);let(p1_hi,p1_lo)=((p1>>64)as u64,p1 as u64);let(r0,borrow)=sub_with_borrow_u64(un[j],p0_lo,false);un[j]=r0;let(r1,borrow1)=sub_with_borrow_u64(un[j+1],p0_hi,borrow);let(r1,borrow2)=sub_with_borrow_u64(r1,p1_lo,false);let borrow=borrow1||borrow2;un[j+1]=r1;let(r2,borrow)=sub_with_borrow_u64(un[j+2],p1_hi,borrow);un[j+2]=r2;assert!(!borrow);}((un[1]as u128)<<64|un[0]as u128)>>v_hi.leading_zeros()}#[doc=" Trait for operations of integer in binary representation."]pub trait BinaryRepr<Size=u32>:Sized+Not<Output=Self>+BitAnd<Output=Self>+BitOr<Output=Self>+BitXor<Output=Self>+Shl<Size,Output=Self>+Shr<Size,Output=Self>+BitAndAssign+BitOrAssign+BitXorAssign+ShlAssign<Size>+ShrAssign<Size>{fn count_ones(self)->Size;fn count_zeros(self)->Size;fn leading_ones(self)->Size;fn leading_zeros(self)->Size;fn reverse_bits(self)->Self;fn rotate_left(self,n:Size)->Self;fn rotate_right(self,n:Size)->Self;fn swap_bytes(self)->Self;fn trailing_ones(self)->Size;fn trailing_zeros(self)->Size;}macro_rules!impl_binary_repr{($($t:ty)*)=>{$(impl BinaryRepr for$t{fn count_ones(self)->u32{self.count_ones()}fn count_zeros(self)->u32{self.count_zeros()}fn leading_ones(self)->u32{self.leading_ones()}fn leading_zeros(self)->u32{self.leading_zeros()}fn reverse_bits(self)->Self{self.reverse_bits()}fn rotate_left(self,n:u32)->Self{self.rotate_left(n)}fn rotate_right(self,n:u32)->Self{self.rotate_right(n)}fn swap_bytes(self)->Self{self.swap_bytes()}fn trailing_ones(self)->u32{self.trailing_ones()}fn trailing_zeros(self)->u32{self.trailing_zeros()}})*};}impl_binary_repr!(u8 i8 u16 i16 u32 i32 u64 i64 u128 i128 usize isize);macro_rules!impl_binop{(impl<$T:ident>$Trait:ident$impl:ident for$t:ty)=>{impl<$T>$Trait for$t where$T:$Trait<Output=$T>,{type Output=Self;fn$impl(self,rhs:Self)->Self::Output{Self($Trait::$impl(self.0,rhs.0))}}impl<$T>$Trait<$T>for$t where$T:$Trait<Output=$T>,{type Output=Self;fn$impl(self,rhs:$T)->Self::Output{Self($Trait::$impl(self.0,rhs))}}};}macro_rules!impl_opassign{(impl<$T:ident>$Trait:ident$impl:ident for$t:ty)=>{impl<$T>$Trait for$t where$T:$Trait,{fn$impl(&mut self,rhs:Self){$Trait::$impl(&mut self.0,rhs.0)}}impl<$T>$Trait<$T>for$t where$T:$Trait,{fn$impl(&mut self,rhs:$T){$Trait::$impl(&mut self.0,rhs)}}};(impl<$T:ident>$Trait:ident$impl:ident for$t:ty=>$F:ident$f:ident)=>{impl<$T>$Trait for$t where$t:$F<Output=$t>+Copy,{fn$impl(&mut self,rhs:Self){*self=$F::$f(*self,rhs);}}impl<$T>$Trait<$T>for$t where$t:$F<$T,Output=$t>+Copy,{fn$impl(&mut self,rhs:$T){*self=$F::$f(*self,rhs);}}};}#[derive(Default,PartialEq,Eq,PartialOrd,Ord,Hash,Clone,Copy)]#[repr(transparent)]#[doc=" Wrapper type of arithmetic `saturating_*` operations."]pub struct Saturating<T>(pub T);pub trait Saturatingable:Sized where Saturating<Self>:Copy+Bounded+Zero+One+Eq+Ord+Default+FromStr+Display+Add<Output=Saturating<Self>>+Sub<Output=Saturating<Self>>+Mul<Output=Saturating<Self>>+Div<Output=Saturating<Self>>+Rem<Output=Saturating<Self>>+BitAnd<Output=Saturating<Self>>+BitOr<Output=Saturating<Self>>+BitXor<Output=Saturating<Self>>+Shl<u32,Output=Saturating<Self>>+Shr<u32,Output=Saturating<Self>>+AddAssign+SubAssign+MulAssign+DivAssign+RemAssign+BitAndAssign+BitOrAssign+BitXorAssign+ShlAssign<u32>+ShrAssign<u32>+Not<Output=Saturating<Self>>+Add<Self,Output=Saturating<Self>>+Sub<Self,Output=Saturating<Self>>+Mul<Self,Output=Saturating<Self>>+Div<Self,Output=Saturating<Self>>+Rem<Self,Output=Saturating<Self>>+BitAnd<Self,Output=Saturating<Self>>+BitOr<Self,Output=Saturating<Self>>+BitXor<Self,Output=Saturating<Self>>+AddAssign<Self>+SubAssign<Self>+MulAssign<Self>+DivAssign<Self>+RemAssign<Self>+BitAndAssign<Self>+BitOrAssign<Self>+BitXorAssign<Self>{fn to_saturating(self)->Saturating<Self>{Saturating(self)}fn from_saturating(s:Saturating<Self>)->Self{s.0}}impl<T>fmt::Debug for Saturating<T>where T:fmt::Debug{fn fmt(&self,f:&mut fmt::Formatter<'_>)->fmt::Result{T::fmt(&self.0,f)}}impl<T>Bounded for Saturating<T>where T:Bounded{fn maximum()->Self{Self(T::maximum())}fn minimum()->Self{Self(T::minimum())}}impl<T>Zero for Saturating<T>where T:Zero{fn zero()->Self{Self(T::zero())}}impl<T>One for Saturating<T>where T:One{fn one()->Self{Self(T::one())}}impl<T>FromStr for Saturating<T>where T:FromStr{type Err=T::Err;fn from_str(s:&str)->Result<Self,Self::Err>{T::from_str(s).map(Self)}}impl<T>Display for Saturating<T>where T:Display{fn fmt(&self,f:&mut fmt::Formatter<'_>)->fmt::Result{T::fmt(&self.0,f)}}impl<T>Scan for Saturating<T>where T:Scan<Output=T>{type Output=Self;fn scan<I:ScanSource>(iter:&mut I)->Option<Self::Output>{T::scan(iter).map(Self)}}impl_binop!(impl<T>Div div for Saturating<T>);impl_binop!(impl<T>Rem rem for Saturating<T>);impl_binop!(impl<T>BitAnd bitand for Saturating<T>);impl_binop!(impl<T>BitOr bitor for Saturating<T>);impl_binop!(impl<T>BitXor bitxor for Saturating<T>);impl_opassign!(impl<T>AddAssign add_assign for Saturating<T> =>Add add);impl_opassign!(impl<T>SubAssign sub_assign for Saturating<T> =>Sub sub);impl_opassign!(impl<T>MulAssign mul_assign for Saturating<T> =>Mul mul);impl_opassign!(impl<T>DivAssign div_assign for Saturating<T>);impl_opassign!(impl<T>RemAssign rem_assign for Saturating<T>);impl_opassign!(impl<T>BitAndAssign bitand_assign for Saturating<T>);impl_opassign!(impl<T>BitOrAssign bitor_assign for Saturating<T>);impl_opassign!(impl<T>BitXorAssign bitxor_assign for Saturating<T>);impl<T>Not for Saturating<T>where T:Not<Output=T>{type Output=Self;fn not(self)->Self::Output{Self(Not::not(self.0))}}macro_rules!impl_int_base_for_saturating{($($t:ty)*)=>{$(impl Saturatingable for$t{}impl Add for Saturating<$t>{type Output=Self;fn add(self,rhs:Self)->Self::Output{Self(self.0 .saturating_add(rhs.0))}}impl Add<$t>for Saturating<$t>{type Output=Self;fn add(self,rhs:$t)->Self::Output{Self(self.0 .saturating_add(rhs))}}impl Sub for Saturating<$t>{type Output=Self;fn sub(self,rhs:Self)->Self::Output{Self(self.0 .saturating_sub(rhs.0))}}impl Sub<$t>for Saturating<$t>{type Output=Self;fn sub(self,rhs:$t)->Self::Output{Self(self.0 .saturating_sub(rhs))}}impl Mul for Saturating<$t>{type Output=Self;fn mul(self,rhs:Self)->Self::Output{Self(self.0 .saturating_mul(rhs.0))}}impl Mul<$t>for Saturating<$t>{type Output=Self;fn mul(self,rhs:$t)->Self::Output{Self(self.0 .saturating_mul(rhs))}}impl Sum for Saturating<$t>{fn sum<I:Iterator<Item=Self>>(iter:I)->Self{iter.fold(Self::zero(),|acc,x|acc+x)}}impl Product for Saturating<$t>{fn product<I:Iterator<Item=Self>>(iter:I)->Self{iter.fold(Self::one(),|acc,x|acc*x)}}impl IntBase for Saturating<$t>{type Error=<$t as IntBase>::Error;fn div_euclid(self,rhs:Self)->Self{Self(self.0 .div_euclid(rhs.0))}fn rem_euclid(self,rhs:Self)->Self{Self(self.0 .rem_euclid(rhs.0))}fn pow(self,exp:u32)->Self{Self(self.0 .saturating_pow(exp))}fn from_str_radix(src:&str,radix:u32)->Result<Self,Self::Error>{<$t as IntBase>::from_str_radix(src,radix).map(Self)}fn ilog(self,base:Self)->u32{self.0 .ilog(base.0)}fn ilog2(self)->u32{self.0 .ilog2()}fn ilog10(self)->u32{self.0 .ilog10()}fn isqrt(self)->Self{Self(self.0 .isqrt())}fn midpoint(self,rhs:Self)->Self{Self(self.0 .midpoint(rhs.0))}}impl From<$t>for Saturating<$t>{fn from(t:$t)->Self{Self(t)}})*};}impl_int_base_for_saturating!(u8 i8 u16 i16 u32 i32 u64 i64 u128 i128 usize isize);macro_rules!impl_unsigned_signed_for_saturating{($($unsigned:ident$signed:ident)*)=>{$(impl Unsigned for Saturating<$unsigned>{type Signed=Saturating<$signed>;fn signed(self)->Self::Signed{Saturating(TryFrom::try_from(self.0).ok().unwrap_or_else($signed::maximum))}fn abs_diff(self,other:Self)->Self{Self(self.0 .abs_diff(other.0))}fn div_ceil(self,rhs:Self)->Self{Self(self.0 .div_ceil(rhs.0))}fn is_power_of_two(self)->bool{self.0 .is_power_of_two()}fn next_power_of_two(self)->Self{Self(self.0 .next_power_of_two())}fn is_multiple_of(self,rhs:Self)->bool{self.0 .is_multiple_of(rhs.0)}fn next_multiple_of(self,rhs:Self)->Self{Self(self.0 .next_multiple_of(rhs.0))}fn gcd(self,other:Self)->Self{Self(self.0 .gcd(other.0))}fn mod_add(self,rhs:Self,modulo:Self)->Self{Self(self.0 .mod_add(rhs.0,modulo.0))}fn mod_sub(self,rhs:Self,modulo:Self)->Self{Self(self.0 .mod_sub(rhs.0,modulo.0))}fn mod_mul(self,rhs:Self,modulo:Self)->Self{Self(self.0 .mod_mul(rhs.0,modulo.0))}}impl Signed for Saturating<$signed>{type Unsigned=Saturating<$unsigned>;fn unsigned(self)->Self::Unsigned{Saturating(TryFrom::try_from(self.0).ok().unwrap_or_else($unsigned::minimum))}fn abs(self)->Self{Self(self.0 .saturating_abs())}fn abs_diff(self,other:Self)->Self::Unsigned{Saturating(self.0 .abs_diff(other.0))}fn is_negative(self)->bool{self.0 .is_negative()}fn is_positive(self)->bool{self.0 .is_positive()}fn signum(self)->Self{Self(self.0 .signum())}}impl Neg for Saturating<$signed>{type Output=Self;fn neg(self)->Self::Output{Self(self.0 .saturating_neg())}})*};}impl_unsigned_signed_for_saturating!(u8 i8 u16 i16 u32 i32 u64 i64 u128 i128 usize isize);macro_rules!impl_binary_repr_for_saturating{($($t:ty)*)=>{$(impl Shl<u32>for Saturating<$t>{type Output=Self;fn shl(self,rhs:u32)->Self::Output{Self(self.0 .checked_shl(rhs).unwrap_or(0))}}impl Shr<u32>for Saturating<$t>{type Output=Self;fn shr(self,rhs:u32)->Self::Output{Self(self.0 .checked_shr(rhs).unwrap_or(0))}}impl ShlAssign<u32>for Saturating<$t>{fn shl_assign(&mut self,rhs:u32){*self=Shl::shl(*self,rhs);}}impl ShrAssign<u32>for Saturating<$t>{fn shr_assign(&mut self,rhs:u32){*self=Shr::shr(*self,rhs);}}impl BinaryRepr for Saturating<$t>{fn count_ones(self)->u32{self.0 .count_ones()}fn count_zeros(self)->u32{self.0 .count_zeros()}fn leading_ones(self)->u32{self.0 .leading_ones()}fn leading_zeros(self)->u32{self.0 .leading_zeros()}fn reverse_bits(self)->Self{Self(self.0 .reverse_bits())}fn rotate_left(self,n:u32)->Self{Self(self.0 .rotate_left(n))}fn rotate_right(self,n:u32)->Self{Self(self.0 .rotate_right(n))}fn swap_bytes(self)->Self{Self(self.0 .swap_bytes())}fn trailing_ones(self)->u32{self.0 .trailing_ones()}fn trailing_zeros(self)->u32{self.0 .trailing_zeros()}})*};}impl_binary_repr_for_saturating!(u8 i8 u16 i16 u32 i32 u64 i64 u128 i128 usize isize);#[derive(Default,PartialEq,Eq,PartialOrd,Ord,Hash,Clone,Copy)]#[repr(transparent)]#[doc=" Wrapper type of arithmetic `wrapping_*` operations."]pub struct Wrapping<T>(pub T);pub trait Wrappingable:Sized where Wrapping<Self>:Copy+Bounded+Zero+One+Eq+Ord+Default+FromStr+Display+Add<Output=Wrapping<Self>>+Sub<Output=Wrapping<Self>>+Mul<Output=Wrapping<Self>>+Div<Output=Wrapping<Self>>+Rem<Output=Wrapping<Self>>+BitAnd<Output=Wrapping<Self>>+BitOr<Output=Wrapping<Self>>+BitXor<Output=Wrapping<Self>>+Shl<u32,Output=Wrapping<Self>>+Shr<u32,Output=Wrapping<Self>>+AddAssign+SubAssign+MulAssign+DivAssign+RemAssign+BitAndAssign+BitOrAssign+BitXorAssign+ShlAssign<u32>+ShrAssign<u32>+Not<Output=Wrapping<Self>>+Add<Self,Output=Wrapping<Self>>+Sub<Self,Output=Wrapping<Self>>+Mul<Self,Output=Wrapping<Self>>+Div<Self,Output=Wrapping<Self>>+Rem<Self,Output=Wrapping<Self>>+BitAnd<Self,Output=Wrapping<Self>>+BitOr<Self,Output=Wrapping<Self>>+BitXor<Self,Output=Wrapping<Self>>+AddAssign<Self>+SubAssign<Self>+MulAssign<Self>+DivAssign<Self>+RemAssign<Self>+BitAndAssign<Self>+BitOrAssign<Self>+BitXorAssign<Self>{fn to_wrapping(self)->Wrapping<Self>{Wrapping(self)}fn from_wrapping(w:Wrapping<Self>)->Self{w.0}}impl<T>fmt::Debug for Wrapping<T>where T:fmt::Debug{fn fmt(&self,f:&mut fmt::Formatter<'_>)->fmt::Result{T::fmt(&self.0,f)}}impl<T>Bounded for Wrapping<T>where T:Bounded{fn maximum()->Self{Self(T::maximum())}fn minimum()->Self{Self(T::minimum())}}impl<T>Zero for Wrapping<T>where T:Zero{fn zero()->Self{Self(T::zero())}}impl<T>One for Wrapping<T>where T:One{fn one()->Self{Self(T::one())}}impl<T>FromStr for Wrapping<T>where T:FromStr{type Err=T::Err;fn from_str(s:&str)->Result<Self,Self::Err>{T::from_str(s).map(Self)}}impl<T>Display for Wrapping<T>where T:Display{fn fmt(&self,f:&mut fmt::Formatter<'_>)->fmt::Result{T::fmt(&self.0,f)}}impl<T>Scan for Wrapping<T>where T:Scan<Output=T>{type Output=Self;fn scan<I:ScanSource>(iter:&mut I)->Option<Self::Output>{T::scan(iter).map(Self)}}impl_binop!(impl<T>BitAnd bitand for Wrapping<T>);impl_binop!(impl<T>BitOr bitor for Wrapping<T>);impl_binop!(impl<T>BitXor bitxor for Wrapping<T>);impl_opassign!(impl<T>AddAssign add_assign for Wrapping<T> =>Add add);impl_opassign!(impl<T>SubAssign sub_assign for Wrapping<T> =>Sub sub);impl_opassign!(impl<T>MulAssign mul_assign for Wrapping<T> =>Mul mul);impl_opassign!(impl<T>DivAssign div_assign for Wrapping<T> =>Div div);impl_opassign!(impl<T>RemAssign rem_assign for Wrapping<T> =>Rem rem);impl_opassign!(impl<T>BitAndAssign bitand_assign for Wrapping<T>);impl_opassign!(impl<T>BitOrAssign bitor_assign for Wrapping<T>);impl_opassign!(impl<T>BitXorAssign bitxor_assign for Wrapping<T>);impl<T>Not for Wrapping<T>where T:Not<Output=T>{type Output=Self;fn not(self)->Self::Output{Self(Not::not(self.0))}}macro_rules!impl_int_base_for_wrapping{($($t:ty)*)=>{$(impl Wrappingable for$t{}impl Add for Wrapping<$t>{type Output=Self;fn add(self,rhs:Self)->Self::Output{Self(self.0 .wrapping_add(rhs.0))}}impl Add<$t>for Wrapping<$t>{type Output=Self;fn add(self,rhs:$t)->Self::Output{Self(self.0 .wrapping_add(rhs))}}impl Sub for Wrapping<$t>{type Output=Self;fn sub(self,rhs:Self)->Self::Output{Self(self.0 .wrapping_sub(rhs.0))}}impl Sub<$t>for Wrapping<$t>{type Output=Self;fn sub(self,rhs:$t)->Self::Output{Self(self.0 .wrapping_sub(rhs))}}impl Mul for Wrapping<$t>{type Output=Self;fn mul(self,rhs:Self)->Self::Output{Self(self.0 .wrapping_mul(rhs.0))}}impl Mul<$t>for Wrapping<$t>{type Output=Self;fn mul(self,rhs:$t)->Self::Output{Self(self.0 .wrapping_mul(rhs))}}impl Div for Wrapping<$t>{type Output=Self;fn div(self,rhs:Self)->Self::Output{Self(self.0 .wrapping_div(rhs.0))}}impl Div<$t>for Wrapping<$t>{type Output=Self;fn div(self,rhs:$t)->Self::Output{Self(self.0 .wrapping_div(rhs))}}impl Rem for Wrapping<$t>{type Output=Self;fn rem(self,rhs:Self)->Self::Output{Self(self.0 .wrapping_rem(rhs.0))}}impl Rem<$t>for Wrapping<$t>{type Output=Self;fn rem(self,rhs:$t)->Self::Output{Self(self.0 .wrapping_rem(rhs))}}impl Sum for Wrapping<$t>{fn sum<I:Iterator<Item=Self>>(iter:I)->Self{iter.fold(Self::zero(),|acc,x|acc+x)}}impl Product for Wrapping<$t>{fn product<I:Iterator<Item=Self>>(iter:I)->Self{iter.fold(Self::one(),|acc,x|acc*x)}}impl IntBase for Wrapping<$t>{type Error=<$t as IntBase>::Error;fn div_euclid(self,rhs:Self)->Self{Self(self.0 .wrapping_div_euclid(rhs.0))}fn rem_euclid(self,rhs:Self)->Self{Self(self.0 .wrapping_rem_euclid(rhs.0))}fn pow(self,exp:u32)->Self{Self(self.0 .wrapping_pow(exp))}fn from_str_radix(src:&str,radix:u32)->Result<Self,Self::Error>{<$t as IntBase>::from_str_radix(src,radix).map(Self)}fn ilog(self,base:Self)->u32{self.0 .ilog(base.0)}fn ilog2(self)->u32{self.0 .ilog2()}fn ilog10(self)->u32{self.0 .ilog10()}fn isqrt(self)->Self{Self(self.0 .isqrt())}fn midpoint(self,rhs:Self)->Self{Self(self.0 .midpoint(rhs.0))}}impl From<$t>for Wrapping<$t>{fn from(t:$t)->Self{Self(t)}})*};}impl_int_base_for_wrapping!(u8 i8 u16 i16 u32 i32 u64 i64 u128 i128 usize isize);macro_rules!impl_unsigned_signed_for_wrapping{($($unsigned:ident$signed:ident)*)=>{$(impl Unsigned for Wrapping<$unsigned>{type Signed=Wrapping<$signed>;fn signed(self)->Self::Signed{Wrapping(self.0 .signed())}fn abs_diff(self,other:Self)->Self{Self(self.0 .abs_diff(other.0))}fn div_ceil(self,rhs:Self)->Self{Self(self.0 .div_ceil(rhs.0))}fn is_power_of_two(self)->bool{self.0 .is_power_of_two()}fn next_power_of_two(self)->Self{Self(self.0 .next_power_of_two())}fn is_multiple_of(self,rhs:Self)->bool{self.0 .is_multiple_of(rhs.0)}fn next_multiple_of(self,rhs:Self)->Self{Self(self.0 .next_multiple_of(rhs.0))}fn gcd(self,other:Self)->Self{Self(self.0 .gcd(other.0))}fn mod_add(self,rhs:Self,modulo:Self)->Self{Self(self.0 .mod_add(rhs.0,modulo.0))}fn mod_sub(self,rhs:Self,modulo:Self)->Self{Self(self.0 .mod_sub(rhs.0,modulo.0))}fn mod_mul(self,rhs:Self,modulo:Self)->Self{Self(self.0 .mod_mul(rhs.0,modulo.0))}}impl Signed for Wrapping<$signed>{type Unsigned=Wrapping<$unsigned>;fn unsigned(self)->Self::Unsigned{Wrapping(self.0 .unsigned())}fn abs(self)->Self{Self(self.0 .wrapping_abs())}fn abs_diff(self,other:Self)->Self::Unsigned{Wrapping(self.0 .abs_diff(other.0))}fn is_negative(self)->bool{self.0 .is_negative()}fn is_positive(self)->bool{self.0 .is_positive()}fn signum(self)->Self{Self(self.0 .signum())}}impl Neg for Wrapping<$signed>{type Output=Self;fn neg(self)->Self::Output{Self(self.0 .wrapping_neg())}})*};}impl_unsigned_signed_for_wrapping!(u8 i8 u16 i16 u32 i32 u64 i64 u128 i128 usize isize);macro_rules!impl_binary_repr_for_wrapping{($($t:ty)*)=>{$(impl Shl<u32>for Wrapping<$t>{type Output=Self;fn shl(self,rhs:u32)->Self::Output{Self(self.0 .wrapping_shl(rhs))}}impl Shr<u32>for Wrapping<$t>{type Output=Self;fn shr(self,rhs:u32)->Self::Output{Self(self.0 .wrapping_shr(rhs))}}impl ShlAssign<u32>for Wrapping<$t>{fn shl_assign(&mut self,rhs:u32){*self=Shl::shl(*self,rhs);}}impl ShrAssign<u32>for Wrapping<$t>{fn shr_assign(&mut self,rhs:u32){*self=Shr::shr(*self,rhs);}}impl BinaryRepr for Wrapping<$t>{fn count_ones(self)->u32{self.0 .count_ones()}fn count_zeros(self)->u32{self.0 .count_zeros()}fn leading_ones(self)->u32{self.0 .leading_ones()}fn leading_zeros(self)->u32{self.0 .leading_zeros()}fn reverse_bits(self)->Self{Self(self.0 .reverse_bits())}fn rotate_left(self,n:u32)->Self{Self(self.0 .rotate_left(n))}fn rotate_right(self,n:u32)->Self{Self(self.0 .rotate_right(n))}fn swap_bytes(self)->Self{Self(self.0 .swap_bytes())}fn trailing_ones(self)->u32{self.0 .trailing_ones()}fn trailing_zeros(self)->u32{self.0 .trailing_zeros()}})*};}impl_binary_repr_for_wrapping!(u8 i8 u16 i16 u32 i32 u64 i64 u128 i128 usize isize);}
// codesnip-guard: ring
#[cfg_attr(any(),rustfmt::skip)]pub use self::ring::*;#[cfg_attr(any(),rustfmt::skip)]mod ring{use super::*;use std::{marker::PhantomData,num::Wrapping,ops::{Add,Mul}};pub trait SemiRing{type T:Clone;type Additive:AbelianMonoid<T=Self::T>;type Multiplicative:Monoid<T=Self::T>;#[doc=" additive identity: $0$"]fn zero()->Self::T{<Self::Additive as Unital>::unit()}fn is_zero(x:&Self::T)->bool where Self::T:PartialEq{*x==Self::zero()}#[doc=" multiplicative identity: $1$"]fn one()->Self::T{<Self::Multiplicative as Unital>::unit()}fn is_one(x:&Self::T)->bool where Self::T:PartialEq{*x==Self::one()}#[doc=" additive operaion: $+$"]fn add(x:&Self::T,y:&Self::T)->Self::T{<Self::Additive as Magma>::operate(x,y)}#[doc=" multiplicative operaion: $+$"]fn mul(x:&Self::T,y:&Self::T)->Self::T{<Self::Multiplicative as Magma>::operate(x,y)}fn try_matrix_product(_a:&[Vec<Self::T>],_b:&[Vec<Self::T>])->Option<Vec<Vec<Self::T>>>{None}fn dot_product(x:&[Self::T],y:&[Self::T])->Self::T{assert_eq!(x.len(),y.len());x.iter().zip(y).fold(Self::zero(),|mut sum,(x,y)|{Self::add_assign(&mut sum,&Self::mul(x,y));sum})}fn add_scaled_assign(x:&mut[Self::T],y:&[Self::T],a:&Self::T){assert_eq!(x.len(),y.len());for(x,y)in x.iter_mut().zip(y){Self::add_assign(x,&Self::mul(a,y));}}fn add_assign(x:&mut Self::T,y:&Self::T){<Self::Additive as Magma>::operate_assign(x,y);}fn mul_assign(x:&mut Self::T,y:&Self::T){<Self::Multiplicative as Magma>::operate_assign(x,y);}}pub trait Ring:SemiRing<Additive:Invertible>{#[doc=" additive inverse: $-$"]fn neg(x:&Self::T)->Self::T{<Self::Additive as Invertible>::inverse(x)}#[doc=" additive right inversed operaion: $-$"]fn sub(x:&Self::T,y:&Self::T)->Self::T{<Self::Additive as Invertible>::rinv_operate(x,y)}fn sub_assign(x:&mut Self::T,y:&Self::T){<Self::Additive as Invertible>::rinv_operate_assign(x,y);}}impl<R>Ring for R where R:SemiRing<Additive:Invertible>{}pub trait Field:Ring<Multiplicative:Invertible>{#[doc=" multiplicative inverse: $-$"]fn inv(x:&Self::T)->Self::T{<Self::Multiplicative as Invertible>::inverse(x)}#[doc=" multiplicative right inversed operaion: $-$"]fn div(x:&Self::T,y:&Self::T)->Self::T{<Self::Multiplicative as Invertible>::rinv_operate(x,y)}fn div_assign(x:&mut Self::T,y:&Self::T){<Self::Multiplicative as Invertible>::rinv_operate_assign(x,y);}}impl<F>Field for F where F:Ring<Multiplicative:Invertible>{}pub trait DotProduct:Sized+Clone+Zero+Add<Output=Self>+Mul<Output=Self>{fn try_matrix_product(_a:&[Vec<Self>],_b:&[Vec<Self>])->Option<Vec<Vec<Self>>>{None}fn add_scaled_assign(x:&mut[Self],y:&[Self],a:&Self){assert_eq!(x.len(),y.len());for(x,y)in x.iter_mut().zip(y){*x=x.clone()+a.clone()*y.clone();}}fn dot_product(x:&[Self],y:&[Self])->Self{assert_eq!(x.len(),y.len());x.iter().zip(y).fold(Self::zero(),|sum,(x,y)|sum+x.clone()*y.clone())}}macro_rules!impl_dot_product{($($t:ty)*)=>{$(impl DotProduct for$t{})*};}impl_dot_product!(u8 u16 u32 u64 usize u128 i8 i16 i32 i64 isize i128 f32 f64);impl<T>DotProduct for Wrapping<T>where Wrapping<T>:Clone+Zero+Add<Output=Wrapping<T>>+Mul<Output=Wrapping<T>>{}#[doc=" $+,\\times$"]pub struct AddMulOperation<T>where T:DotProduct+One{_marker:PhantomData<fn()->T>}impl<T>SemiRing for AddMulOperation<T>where T:DotProduct+One{type T=T;type Additive=AdditiveOperation<T>;type Multiplicative=MultiplicativeOperation<T>;#[inline]fn try_matrix_product(a:&[Vec<T>],b:&[Vec<T>])->Option<Vec<Vec<T>>>{T::try_matrix_product(a,b)}#[inline]fn dot_product(x:&[Self::T],y:&[Self::T])->Self::T{T::dot_product(x,y)}#[inline]fn add_scaled_assign(x:&mut[Self::T],y:&[Self::T],a:&Self::T){T::add_scaled_assign(x,y,a);}}}
// codesnip-guard: scanner
#[cfg_attr(any(),rustfmt::skip)]pub use self::scanner::*;#[cfg_attr(any(),rustfmt::skip)]mod scanner{use std::{iter::{FromIterator,from_fn,repeat_with},marker::PhantomData};pub fn read_stdin_all()->String{use std::io::Read as _;let mut s=String::new();std::io::stdin().read_to_string(&mut s).expect("io error");s}pub fn read_stdin_all_unchecked()->String{use std::io::Read as _;let mut buf=Vec::new();std::io::stdin().read_to_end(&mut buf).expect("io error");unsafe{String::from_utf8_unchecked(buf)}}pub fn read_all(mut reader:impl std::io::Read)->String{let mut s=String::new();reader.read_to_string(&mut s).expect("io error");s}pub fn read_all_unchecked(mut reader:impl std::io::Read)->String{let mut buf=Vec::new();reader.read_to_end(&mut buf).expect("io error");unsafe{String::from_utf8_unchecked(buf)}}pub fn read_stdin_line()->String{let mut s=String::new();std::io::stdin().read_line(&mut s).expect("io error");s}pub trait Scan:Sized{type Output;fn scan<S:ScanSource>(source:&mut S)->Option<Self::Output>;fn scan_vec<S:ScanSource>(source:&mut S,size:usize,capacity:usize)->Vec<Self::Output>{let mut values=Vec::with_capacity(capacity.max(size));values.extend((0..size).map(|_|source.scan::<Self>()));values}}pub trait MarkedScan:Sized{type Output;fn mscan<S:ScanSource>(self,source:&mut S)->Option<Self::Output>;}pub trait ScanSource:Sized{#[doc=" Reads a token under the source's input requirements."]#[doc=" Checked sources return `None` at EOF; unchecked sources require available input."]fn next_token(&mut self)->Option<&str>;#[doc=" Skips separators without consuming the next token."]#[inline]fn skip_whitespace(&mut self){}#[inline]fn read_u8(&mut self)->Option<u8>{self.next_token()?.parse().ok()}#[inline]fn read_u16(&mut self)->Option<u16>{self.next_token()?.parse().ok()}#[inline]fn read_u32(&mut self)->Option<u32>{self.next_token()?.parse().ok()}fn read_u32_vec(&mut self,size:usize,capacity:usize)->Vec<u32>{let mut values=Vec::with_capacity(capacity.max(size));values.extend((0..size).map(|_|self.scan::<u32>()));values}#[inline]fn read_u64(&mut self)->Option<u64>{self.next_token()?.parse().ok()}#[inline]fn read_u128(&mut self)->Option<u128>{self.next_token()?.parse().ok()}#[inline]fn read_usize(&mut self)->Option<usize>{self.next_token()?.parse().ok()}#[inline]fn read_i8(&mut self)->Option<i8>{self.next_token()?.parse().ok()}#[inline]fn read_i16(&mut self)->Option<i16>{self.next_token()?.parse().ok()}#[inline]fn read_i32(&mut self)->Option<i32>{self.next_token()?.parse().ok()}#[inline]fn read_i64(&mut self)->Option<i64>{self.next_token()?.parse().ok()}#[inline]fn read_i128(&mut self)->Option<i128>{self.next_token()?.parse().ok()}#[inline]fn read_isize(&mut self)->Option<isize>{self.next_token()?.parse().ok()}#[doc=" Panics if reading fails."]#[inline]fn scan<T:Scan>(&mut self)->T::Output{T::scan(self).expect("scan error")}#[doc=" Panics if reading fails."]#[inline]fn mscan<T:MarkedScan>(&mut self,marker:T)->T::Output{marker.mscan(self).expect("scan error")}fn scan_vec<T:Scan>(&mut self,size:usize,capacity:usize)->Vec<T::Output>{if size==0{self.skip_whitespace();}T::scan_vec(self,size,capacity)}#[inline]fn iter<T:Scan>(&mut self)->ScannerIter<'_,Self,T>{ScannerIter{inner:self,_marker:PhantomData}}}#[derive(Clone,Debug)]pub struct Scanner<'a,I:Iterator<Item=&'a str>=std::str::SplitAsciiWhitespace<'a>>{iter:I}impl<'a>Scanner<'a>{pub fn new(s:&'a str)->Self{Self{iter:s.split_ascii_whitespace()}}}impl<'a,I:Iterator<Item=&'a str>>Scanner<'a,I>{pub fn new_from_iter(iter:I)->Self{Self{iter}}}impl<'a,I:Iterator<Item=&'a str>>ScanSource for Scanner<'a,I>{fn next_token(&mut self)->Option<&str>{self.iter.next()}}macro_rules!impl_scan{($($t:ty)*)=>{$(impl Scan for$t{type Output=Self;fn scan<I:ScanSource>(iter:&mut I)->Option<Self>{iter.next_token()?.parse::<$t>().ok()}})*};}impl_scan!(char f32 f64 String);macro_rules!impl_integer_scan{($($t:ty=>$read:ident),*$(,)?)=>{$(impl Scan for$t{type Output=Self;#[inline]fn scan<S:ScanSource>(source:&mut S)->Option<Self>{source.$read()}})*};}impl_integer_scan!(u8=>read_u8,u16=>read_u16,u64=>read_u64,u128=>read_u128,usize=>read_usize,i8=>read_i8,i16=>read_i16,i32=>read_i32,i64=>read_i64,i128=>read_i128,isize=>read_isize,);impl Scan for u32{type Output=Self;#[inline]fn scan<S:ScanSource>(source:&mut S)->Option<Self>{source.read_u32()}fn scan_vec<S:ScanSource>(source:&mut S,size:usize,capacity:usize)->Vec<Self>{source.read_u32_vec(size,capacity)}}macro_rules!impl_scan_tuple{(@impl$($T:ident)*)=>{impl<$($T:Scan),*>Scan for($($T,)*){type Output=($(<$T as Scan>::Output,)*);fn scan<It:ScanSource>(_iter:&mut It)->Option<Self::Output>{Some(($(<$T as Scan>::scan(_iter)?,)*))}}};(@inner$($T:ident)*,)=>{impl_scan_tuple!(@impl$($T)*);};(@inner$($T:ident)*,$U:ident$($Rest:ident)*)=>{impl_scan_tuple!(@impl$($T)*);impl_scan_tuple!(@inner$($T)*$U,$($Rest)*);};($($T:ident)*)=>{impl_scan_tuple!(@inner,$($T)*);};}impl_scan_tuple!(A B C D E F G H I J K);pub struct ScannerIter<'a,S,T>{inner:&'a mut S,_marker:PhantomData<fn()->T>}impl<S:ScanSource,T:Scan>Iterator for ScannerIter<'_,S,T>{type Item=T::Output;#[inline]fn next(&mut self)->Option<Self::Item>{T::scan(self.inner)}}#[doc=" scan a value with Scanner"]#[doc=""]#[doc=" - `scan_value!(scanner, ELEMENT)`"]#[doc=""]#[doc=" ELEMENT :="]#[doc=" - `$ty`: Scan"]#[doc=" - `&str`: borrowed token; the source stays borrowed until its last use"]#[doc=" - `@$expr`: MarkedScan"]#[doc=" - `$ty = $expr`: MarkedScan"]#[doc=" - `[ELEMENT; $expr]`: vector"]#[doc=" - `[$ty; $len; capacity $capacity]`: vector with reserved capacity"]#[doc=" - `[ELEMENT; const $expr]`: array"]#[doc=" - `[ELEMENT]`: iterator"]#[doc=" - `[ELEMENT; iter $expr]`: iterator of the specified length"]#[doc=" - `($(ELEMENT)*,)`: tuple"]#[macro_export]macro_rules!scan_value{(@repeat$scanner:expr,[$($t:tt)*]$len:expr)=>{{$crate::scan_value!(@iter$scanner,[$($t)*]$len).collect::<Vec<_>>()}};(@repeat$scanner:expr,[$($t:tt)*])=>{{::std::iter::repeat_with(||$crate::scan_value!(@inner$scanner,[]$($t)*))}};(@iter$scanner:expr,[$($t:tt)*]$len:expr)=>{{let size=$len;if size==0{$scanner.skip_whitespace();}$crate::scan_value!(@repeat$scanner,[$($t)*]).take(size)}};(@array$scanner:expr,[$($t:tt)*]$len:expr)=>{{if$len==0{$scanner.skip_whitespace();}$crate::array![||$crate::scan_value!(@inner$scanner,[]$($t)*);$len]}};(@tuple$scanner:expr,[$([$($args:tt)*])*])=>{($($($args)*,)*)};(@sparen$scanner:expr,[]@$e:expr;$($t:tt)*)=>{$crate::scan_value!(@sparen$scanner,[@$e]$($t)*)};(@sparen$scanner:expr,[]($($tt:tt)*);$($t:tt)*)=>{$crate::scan_value!(@sparen$scanner,[($($tt)*)]$($t)*)};(@sparen$scanner:expr,[][$($tt:tt)*];$($t:tt)*)=>{$crate::scan_value!(@sparen$scanner,[[$($tt)*]]$($t)*)};(@sparen$scanner:expr,[]$ty:ty=$e:expr;$($t:tt)*)=>{$crate::scan_value!(@sparen$scanner,[$ty=$e]$($t)*)};(@sparen$scanner:expr,[]$ty:ty;$($t:tt)*)=>{$crate::scan_value!(@sparen$scanner,[$ty]$($t)*)};(@sparen$scanner:expr,[]$($args:tt)*)=>{$crate::scan_value!(@repeat$scanner,[$($args)*])};(@sparen$scanner:expr,[$($args:tt)+]const$len:expr)=>{$crate::scan_value!(@array$scanner,[$($args)+]$len)};(@sparen$scanner:expr,[$($args:tt)+]iter$len:expr)=>{$crate::scan_value!(@iter$scanner,[$($args)+]$len)};(@sparen$scanner:expr,[$($args:tt)+]$len:expr;capacity$capacity:expr)=>{{let size=$len;let capacity=$capacity;$scanner.scan_vec::<$($args)+>(size,capacity)}};(@sparen$scanner:expr,[$($args:tt)+]$len:expr)=>{$crate::scan_value!(@repeat$scanner,[$($args)+]$len)};(@$tag:ident$scanner:expr,[[$($args:tt)*]])=>{$($args)*};(@$tag:ident$scanner:expr,[$($args:tt)*]@$e:expr$(,$($t:tt)*)?)=>{$crate::scan_value!(@$tag$scanner,[$($args)*[$scanner.mscan($e)]]$(,$($t)*)?)};(@$tag:ident$scanner:expr,[$($args:tt)*]($($tuple:tt)*)$($t:tt)*)=>{$crate::scan_value!(@$tag$scanner,[$($args)*[$crate::scan_value!(@tuple$scanner,[]$($tuple)*)]]$($t)*)};(@$tag:ident$scanner:expr,[$($args:tt)*][$($tt:tt)*]$($t:tt)*)=>{$crate::scan_value!(@$tag$scanner,[$($args)*[$crate::scan_value!(@sparen$scanner,[]$($tt)*)]]$($t)*)};(@$tag:ident$scanner:expr,[$($args:tt)*]&str$(,$($t:tt)*)?)=>{$crate::scan_value!(@$tag$scanner,[$($args)*[$scanner.next_token().expect("scan error")]]$(,$($t)*)?)};(@$tag:ident$scanner:expr,[$($args:tt)*]$ty:ty=$e:expr$(,$($t:tt)*)?)=>{$crate::scan_value!(@$tag$scanner,[$($args)*[{let _tmp:$ty=$scanner.mscan($e);_tmp}]]$(,$($t)*)?)};(@$tag:ident$scanner:expr,[$($args:tt)*]$ty:ty$(,$($t:tt)*)?)=>{$crate::scan_value!(@$tag$scanner,[$($args)*[$scanner.scan::<$ty>()]]$(,$($t)*)?)};(@$tag:ident$scanner:expr,[$($args:tt)*],$($t:tt)*)=>{$crate::scan_value!(@$tag$scanner,[$($args)*]$($t)*)};(@$tag:ident$scanner:expr,[$($args:tt)*])=>{::std::compile_error!(::std::stringify!($($args)*))};(src=$src:expr,$($t:tt)*)=>{{let mut __scanner=Scanner::new($src);$crate::scan_value!(@inner __scanner,[]$($t)*)}};(iter=$iter:expr,$($t:tt)*)=>{{let mut __scanner=Scanner::new_from_iter($iter);$crate::scan_value!(@inner __scanner,[]$($t)*)}};($scanner:expr,$($t:tt)*)=>{$crate::scan_value!(@inner$scanner,[]$($t)*)}}#[doc=" scan and bind values with Scanner"]#[doc=""]#[doc=" - `scan!(scanner, $($pat $(: ELEMENT)?),*)`"]#[macro_export]macro_rules!scan{(@assert$p:pat)=>{};(@assert$($p:tt)*)=>{::std::compile_error!(::std::concat!("expected pattern, found `",::std::stringify!($($p)*),"`"));};(@pat$scanner:expr,[][])=>{};(@pat$scanner:expr,[][],$($t:tt)*)=>{$crate::scan!(@pat$scanner,[][]$($t)*)};(@pat$scanner:expr,[$($p:tt)*][]$x:ident$($t:tt)*)=>{$crate::scan!(@pat$scanner,[$($p)*$x][]$($t)*)};(@pat$scanner:expr,[$($p:tt)*][]::$($t:tt)*)=>{$crate::scan!(@pat$scanner,[$($p)*::][]$($t)*)};(@pat$scanner:expr,[$($p:tt)*][]&$($t:tt)*)=>{$crate::scan!(@pat$scanner,[$($p)*&][]$($t)*)};(@pat$scanner:expr,[$($p:tt)*][]($($x:tt)*)$($t:tt)*)=>{$crate::scan!(@pat$scanner,[$($p)*($($x)*)][]$($t)*)};(@pat$scanner:expr,[$($p:tt)*][][$($x:tt)*]$($t:tt)*)=>{$crate::scan!(@pat$scanner,[$($p)*[$($x)*]][]$($t)*)};(@pat$scanner:expr,[$($p:tt)*][]{$($x:tt)*}$($t:tt)*)=>{$crate::scan!(@pat$scanner,[$($p)*{$($x)*}][]$($t)*)};(@pat$scanner:expr,[$($p:tt)*][]:$($t:tt)*)=>{$crate::scan!(@ty$scanner,[$($p)*][]$($t)*)};(@pat$scanner:expr,[$($p:tt)*][]$($t:tt)*)=>{$crate::scan!(@let$scanner,[$($p)*][usize]$($t)*)};(@ty$scanner:expr,[$($p:tt)*][$($tt:tt)*]@$e:expr$(,$($t:tt)*)?)=>{$crate::scan!(@let$scanner,[$($p)*][$($tt)*@$e]$(,$($t)*)?)};(@ty$scanner:expr,[$($p:tt)*][$($tt:tt)*]($($x:tt)*)$($t:tt)*)=>{$crate::scan!(@let$scanner,[$($p)*][$($tt)*($($x)*)]$($t)*)};(@ty$scanner:expr,[$($p:tt)*][$($tt:tt)*][$($x:tt)*]$($t:tt)*)=>{$crate::scan!(@let$scanner,[$($p)*][$($tt)*[$($x)*]]$($t)*)};(@ty$scanner:expr,[$($p:tt)*][$($tt:tt)*]&str$(,$($t:tt)*)?)=>{$crate::scan!(@let$scanner,[$($p)*][$($tt)*&str]$(,$($t)*)?)};(@ty$scanner:expr,[$($p:tt)*][$($tt:tt)*]$ty:ty=$e:expr$(,$($t:tt)*)?)=>{$crate::scan!(@let$scanner,[$($p)*][$($tt)*$ty=$e]$(,$($t)*)?)};(@ty$scanner:expr,[$($p:tt)*][$($tt:tt)*]$ty:ty$(,$($t:tt)*)?)=>{$crate::scan!(@let$scanner,[$($p)*][$($tt)*$ty]$(,$($t)*)?)};(@let$scanner:expr,[$($p:tt)*][$($tt:tt)*]$($t:tt)*)=>{$crate::scan!{@assert$($p)*}let$($p)* =$crate::scan_value!($scanner,$($tt)*);$crate::scan!(@pat$scanner,[][]$($t)*)};(src=$src:expr,$($t:tt)*)=>{let mut __scanner=Scanner::new($src);$crate::scan!(@pat __scanner,[][]$($t)*)};(iter=$iter:expr,$($t:tt)*)=>{let mut __scanner=Scanner::new_from_iter($iter);$crate::scan!(@pat __scanner,[][]$($t)*)};($scanner:expr,$($t:tt)*)=>{$crate::scan!(@pat$scanner,[][]$($t)*)}}#[doc=" define enum scan rules"]#[doc=""]#[doc=" # Example"]#[doc=" ```rust"]#[doc=" # use competitive::{define_enum_scan, tools::{CharsWithBase, Scan, ScanSource, Scanner, Usize1}};"]#[doc=" define_enum_scan! {"]#[doc="   enum Query: u8 {"]#[doc="     0 => Noop,"]#[doc="     1 => Args { i: Usize1, s: char },"]#[doc="     9 => Complex { n: usize, c: [(usize, Vec<usize> = CharsWithBase('a')); n] },"]#[doc="   }"]#[doc=" }"]#[doc=" ```"]#[macro_export]macro_rules!define_enum_scan{(@field_ty@repeat[$($t:tt)*]$($len:expr)?)=>{Vec<$crate::define_enum_scan!(@field_ty$($t)*)>};(@field_ty@array[$($t:tt)*]$len:expr)=>{[$crate::define_enum_scan!(@field_ty$($t)*);$len]};(@field_ty@tuple[$([$($args:tt)*])*])=>{($($($args)*,)*)};(@field_ty@sparen[]($($tt:tt)*);$($t:tt)*)=>{$crate::define_enum_scan!(@field_ty@sparen[($($tt)*)]$($t)*)};(@field_ty@sparen[][$($tt:tt)*];$($t:tt)*)=>{$crate::define_enum_scan!(@field_ty@sparen[[$($tt)*]]$($t)*)};(@field_ty@sparen[]$ty:ty=$e:expr;$($t:tt)*)=>{$crate::define_enum_scan!(@field_ty@sparen[$ty=$e]$($t)*)};(@field_ty@sparen[]$ty:ty;$($t:tt)*)=>{$crate::define_enum_scan!(@field_ty@sparen[$ty]$($t)*)};(@field_ty@sparen[]$($args:tt)*)=>{$crate::define_enum_scan!(@field_ty@repeat[$($args)*])};(@field_ty@sparen[$($args:tt)+]const$len:expr)=>{$crate::define_enum_scan!(@field_ty@array[$($args)+]$len)};(@field_ty@sparen[$($args:tt)+]$len:expr)=>{$crate::define_enum_scan!(@field_ty@repeat[$($args)+]$len)};(@field_ty@$tag:ident[$($args:tt)*]($($tuple:tt)*)$($t:tt)*)=>{$crate::define_enum_scan!(@field_ty@$tag[$($args)*[$crate::define_enum_scan!(@field_ty@tuple[]$($tuple)*)]]$($t)*)};(@field_ty@$tag:ident[$($args:tt)*][$($tt:tt)*]$($t:tt)*)=>{$crate::define_enum_scan!(@field_ty@$tag[$($args)*[$crate::define_enum_scan!(@field_ty@sparen[]$($tt)*)]]$($t)*)};(@field_ty@$tag:ident[$($args:tt)*]$ty:ty=$e:expr$(,$($t:tt)*)?)=>{$crate::define_enum_scan!(@field_ty@$tag[$($args)*[$ty]]$(,$($t)*)?)};(@field_ty@$tag:ident[$($args:tt)*]$ty:ty$(,$($t:tt)*)?)=>{$crate::define_enum_scan!(@field_ty@$tag[$($args)*[<$ty as Scan>::Output]]$(,$($t)*)?)};(@field_ty@$tag:ident[$($args:tt)*],$($t:tt)*)=>{$crate::define_enum_scan!(@field_ty@$tag[$($args)*]$($t)*)};(@field_ty@$tag:ident[[$($args:tt)*]])=>{$($args)*};(@field_ty@$tag:ident[$($args:tt)*])=>{::std::compile_error!(::std::stringify!($($args)*))};(@field_ty$($t:tt)*)=>{$crate::define_enum_scan!(@field_ty@inner[]$($t)*)};(@tag_expr raw,$iter:ident)=>{ScanSource::next_token($iter)?};(@tag_expr$d:ty,$iter:ident)=>{<$d as Scan>::scan($iter)?};(@variant([$($attr:tt)*]$vis:vis$T:ident$d:tt)[$($vars:tt)*])=>{$crate::define_enum_scan!{@def$($attr)*$vis enum$T:$d{$($vars)*}}};(@variant$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident{$($fs:tt)*}$($rest:tt)*)=>{$crate::define_enum_scan!{@field$ctx[$($vars)*]$p=>$v[]$($fs)*;$($rest)*}};(@variant$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident$($rest:tt)*)=>{$crate::define_enum_scan!{@variant$ctx[$($vars)*$p=>$v,]$($rest)*}};(@variant$ctx:tt[$($vars:tt)*],$($rest:tt)*)=>{$crate::define_enum_scan!{@variant$ctx[$($vars)*]$($rest)*}};(@endfield$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident[$($fs:tt)*][$f:ident:$($spec:tt)*],$($rest:tt)*)=>{$crate::define_enum_scan!{@field$ctx[$($vars)*]$p=>$v[$($fs)*[$f:$($spec)*]]$($rest)*}};(@endfield$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident[$($fs:tt)*][$f:ident:$($spec:tt)*];$($rest:tt)*)=>{$crate::define_enum_scan!{@variant$ctx[$($vars)*$p=>$v{$($fs)*[$f:$($spec)*]},]$($rest)*}};(@field$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident[$($fs:tt)*];$($rest:tt)*)=>{$crate::define_enum_scan!{@variant$ctx[$($vars)*$p=>$v{$($fs)*},]$($rest)*}};(@field$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident[$($fs:tt)*]$f:ident:($($tuple:tt)*)$sep:tt$($rest:tt)*)=>{$crate::define_enum_scan!{@endfield$ctx[$($vars)*]$p=>$v[$($fs)*][$f:($($tuple)*)]$sep$($rest)*}};(@field$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident[$($fs:tt)*]$f:ident:[$($x:tt)*]$sep:tt$($rest:tt)*)=>{$crate::define_enum_scan!{@endfield$ctx[$($vars)*]$p=>$v[$($fs)*][$f:[$($x)*]]$sep$($rest)*}};(@field$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident[$($fs:tt)*]$f:ident:$ty:ty=$e:expr,$($rest:tt)*)=>{$crate::define_enum_scan!{@endfield$ctx[$($vars)*]$p=>$v[$($fs)*][$f:$ty=$e],$($rest)*}};(@field$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident[$($fs:tt)*]$f:ident:$ty:ty;$($rest:tt)*)=>{$crate::define_enum_scan!{@endfield$ctx[$($vars)*]$p=>$v[$($fs)*][$f:$ty];$($rest)*}};(@field$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident[$($fs:tt)*]$f:ident:$ty:ty=$e:expr;$($rest:tt)*)=>{$crate::define_enum_scan!{@endfield$ctx[$($vars)*]$p=>$v[$($fs)*][$f:$ty=$e];$($rest)*}};(@field$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident[$($fs:tt)*]$f:ident:$ty:ty,$($rest:tt)*)=>{$crate::define_enum_scan!{@endfield$ctx[$($vars)*]$p=>$v[$($fs)*][$f:$ty],$($rest)*}};(@def$(#[$attr:meta])*$vis:vis enum$T:ident:$d:tt{$($p:pat=>$v:ident$({$([$f:ident:$($spec:tt)*])*})?,)*})=>{$(#[$attr])*$vis enum$T{$($v$({$($f:$crate::define_enum_scan!(@field_ty$($spec)*)),*})?),*}impl Scan for$T{type Output=Self;fn scan<I:ScanSource>(iter:&mut I)->Option<Self>{let tag=$crate::define_enum_scan!(@tag_expr$d,iter);match tag{$($p=>{$($(let$f=$crate::scan_value!((*iter),$($spec)*);)*)?Some($T::$v$({$($f),*})?)}),*_=>None,}}}};($(#[$attr:meta])*$vis:vis enum$T:ident:raw{$($body:tt)*})=>{$crate::define_enum_scan!{@variant([$(#[$attr])*]$vis$T raw)[]$($body)*}};($(#[$attr:meta])*$vis:vis enum$T:ident:$d:ty{$($body:tt)*})=>{$crate::define_enum_scan!{@variant([$(#[$attr])*]$vis$T$d)[]$($body)*}};}#[derive(Debug,Copy,Clone)]pub enum Usize1{}impl Scan for Usize1{type Output=usize;fn scan<I:ScanSource>(iter:&mut I)->Option<Self::Output>{<usize as Scan>::scan(iter)?.checked_sub(1)}}#[derive(Debug,Copy,Clone)]pub struct CharWithBase(pub char);impl MarkedScan for CharWithBase{type Output=usize;fn mscan<I:ScanSource>(self,iter:&mut I)->Option<Self::Output>{Some((<char as Scan>::scan(iter)?as u8-self.0 as u8)as usize)}}#[derive(Debug,Copy,Clone)]pub enum Chars{}impl Scan for Chars{type Output=Vec<char>;fn scan<I:ScanSource>(iter:&mut I)->Option<Self::Output>{Some(iter.next_token()?.chars().collect())}}#[derive(Debug,Copy,Clone)]pub struct CharsWithBase(pub char);impl MarkedScan for CharsWithBase{type Output=Vec<usize>;fn mscan<I:ScanSource>(self,iter:&mut I)->Option<Self::Output>{Some(iter.next_token()?.chars().map(|c|(c as u8-self.0 as u8)as usize).collect())}}#[derive(Debug,Copy,Clone)]pub enum Byte1{}impl Scan for Byte1{type Output=u8;fn scan<I:ScanSource>(iter:&mut I)->Option<Self::Output>{let bytes=iter.next_token()?.as_bytes();assert_eq!(bytes.len(),1);Some(bytes[0])}}#[derive(Debug,Copy,Clone)]pub struct ByteWithBase(pub u8);impl MarkedScan for ByteWithBase{type Output=usize;fn mscan<I:ScanSource>(self,iter:&mut I)->Option<Self::Output>{Some((<char as Scan>::scan(iter)?as u8-self.0)as usize)}}#[derive(Debug,Copy,Clone)]pub enum Bytes{}impl Scan for Bytes{type Output=Vec<u8>;fn scan<I:ScanSource>(iter:&mut I)->Option<Self::Output>{Some(iter.next_token()?.bytes().collect())}}#[derive(Debug,Copy,Clone)]pub struct BytesWithBase(pub u8);impl MarkedScan for BytesWithBase{type Output=Vec<usize>;fn mscan<I:ScanSource>(self,iter:&mut I)->Option<Self::Output>{Some(iter.next_token()?.bytes().map(|c|(c-self.0)as usize).collect())}}#[derive(Debug,Copy,Clone)]pub struct Collect<T,B=Vec<<T as Scan>::Output>>where T:Scan,B:FromIterator<<T as Scan>::Output>{size:usize,_marker:PhantomData<fn()->(T,B)>}impl<T,B>Collect<T,B>where T:Scan,B:FromIterator<<T as Scan>::Output>{pub fn new(size:usize)->Self{Self{size,_marker:PhantomData}}}impl<T,B>MarkedScan for Collect<T,B>where T:Scan,B:FromIterator<<T as Scan>::Output>{type Output=B;fn mscan<I:ScanSource>(self,iter:&mut I)->Option<Self::Output>{if self.size==0{iter.skip_whitespace();}repeat_with(| |<T as Scan>::scan(iter)).take(self.size).collect()}}#[derive(Debug,Copy,Clone)]pub struct SizedCollect<T,B=Vec<<T as Scan>::Output>>where T:Scan,B:FromIterator<<T as Scan>::Output>{_marker:PhantomData<fn()->(T,B)>}impl<T,B>Scan for SizedCollect<T,B>where T:Scan,B:FromIterator<<T as Scan>::Output>{type Output=B;fn scan<I:ScanSource>(iter:&mut I)->Option<Self::Output>{let size=usize::scan(iter)?;if size==0{iter.skip_whitespace();}repeat_with(| |<T as Scan>::scan(iter)).take(size).collect()}}#[derive(Debug,Copy,Clone)]pub struct Splitted<T,P>where T:Scan{pat:P,_marker:PhantomData<fn()->T>}impl<T,P>Splitted<T,P>where T:Scan{pub fn new(pat:P)->Self{Self{pat,_marker:PhantomData}}}impl<T>MarkedScan for Splitted<T,char>where T:Scan{type Output=Vec<<T as Scan>::Output>;fn mscan<I:ScanSource>(self,iter:&mut I)->Option<Self::Output>{let mut iter=Scanner::new_from_iter(iter.next_token()?.split(self.pat));Some(from_fn(| |<T as Scan>::scan(&mut iter)).collect())}}impl<T>MarkedScan for Splitted<T,&str>where T:Scan{type Output=Vec<<T as Scan>::Output>;fn mscan<I:ScanSource>(self,iter:&mut I)->Option<Self::Output>{let mut iter=Scanner::new_from_iter(iter.next_token()?.split(self.pat));Some(from_fn(| |<T as Scan>::scan(&mut iter)).collect())}}impl<T,F>MarkedScan for F where F:Fn(&str)->Option<T>{type Output=T;fn mscan<I:ScanSource>(self,iter:&mut I)->Option<Self::Output>{self(iter.next_token()?)}}}
// codesnip-guard: zero_one
#[cfg_attr(any(),rustfmt::skip)]pub use self::zero_one::{One,Zero};#[cfg_attr(any(),rustfmt::skip)]mod zero_one{pub trait Zero:Sized{fn zero()->Self;#[inline]fn is_zero(&self)->bool where Self:PartialEq{self==&Self::zero()}#[inline]fn set_zero(&mut self){*self=Self::zero();}}pub trait One:Sized{fn one()->Self;#[inline]fn is_one(&self)->bool where Self:PartialEq{self==&Self::one()}#[inline]fn set_one(&mut self){*self=Self::one();}}macro_rules!impl_zero_one{($({$(<$T:ident:$Bound:ident>)?$Trait:ident$method:ident$($t:ty)*,$e:expr})*)=>{$(impl_zero_one!(@impl[$(<$T:$Bound>)?]$Trait$method[$($t)*],$e);)*};(@impl[<$T:ident:$Bound:ident>]$Trait:ident$method:ident[$($t:ty)*],$e:expr)=>{$(impl<$T:$Bound>$Trait for$t{fn$method()->Self{$e}})*};(@impl[]$Trait:ident$method:ident[$($t:ty)*],$e:expr)=>{$(impl$Trait for$t{fn$method()->Self{$e}})*};}impl_zero_one!({Zero zero u8 u16 u32 u64 usize i8 i16 i32 i64 isize u128 i128,0}{Zero zero f32 f64,0.}{One one u8 u16 u32 u64 usize i8 i16 i32 i64 isize u128 i128,1}{One one f32 f64,1.}{<T:Zero>Zero zero std::num::Wrapping<T>,Self(T::zero())}{<T:One>One one std::num::Wrapping<T>,Self(T::one())});}