// codesnip-guard: SqrtTree
#[cfg_attr(any(),rustfmt::skip)]pub use self::sqrt_tree::{SqrtFoldMap,SqrtFoldVec,SqrtIntoIter,SqrtIter,SqrtLazyMap,SqrtLazyVec,SqrtMap,SqrtMultiset,SqrtSet,SqrtVec};#[cfg_attr(any(),rustfmt::skip)]mod sqrt_tree{use super::{LazyMapAct,LazyMapAgg,LazyMapMonoidWithKeyAct,Monoid,RangeBoundsExt};use std::{mem,ops::{Bound,RangeBounds}};pub use self::fold::{SqrtFoldMap,SqrtFoldVec};pub use self::lazy::{SqrtLazyMap,SqrtLazyVec};pub use self::plain::{SqrtIntoIter,SqrtIter,SqrtMap,SqrtMultiset,SqrtSet,SqrtVec};mod fold{use super::{Bucket,BucketState,BucketValue,Buckets,MapValue,Monoid,RangeBoundsExt,SequenceValue,sort_dedup_map};use std::{borrow::Borrow,marker::PhantomData,mem,ops::{Range,RangeBounds}};struct FoldState<M,P>where M:Monoid{agg:M::T,_marker:PhantomData<fn()->P>}impl<T,M,P>BucketState<T>for FoldState<M,P>where M:Monoid,P:BucketValue<T,Value=M::T>{fn new(values:&[T])->Self{let agg=values.iter().fold(M::unit(),|agg,value|M::operate(&agg,P::get(value)));Self{agg,_marker:PhantomData}}fn push(&mut self,_:&mut[T]){}}impl<T,M,P>Buckets<T,FoldState<M,P>>where M:Monoid,P:BucketValue<T,Value=M::T>{fn fold(&self,range:Range<usize>)->M::T{assert!(range.start<=range.end);let mut result=M::unit();let mut offset=0;for Bucket{values,state}in&self.buckets{let end=offset+values.len();if range.end<=offset{break;}if range.start<=offset&&end<=range.end{result=M::operate(&result,&state.agg);}else if range.start<end{for value in&values[range.start.saturating_sub(offset)..range.end.min(end)-offset]{result=M::operate(&result,P::get(value));}}offset=end;}result}}#[doc=" A sequence with ordered range aggregation and no lazy updates."]#[doc=" With O(1) monoid operations, folds and amortized updates take O(sqrt(N))."]pub struct SqrtFoldVec<M>where M:Monoid{inner:Buckets<M::T,FoldState<M,SequenceValue>>}impl<M>SqrtFoldVec<M>where M:Monoid{pub fn new()->Self{Self{inner:Buckets::new()}}pub fn len(&self)->usize{self.inner.len}pub fn is_empty(&self)->bool{self.len()==0}pub fn clear(&mut self){*self=Self::new();}pub fn get(&self,index:usize)->Option<&M::T>{if index>=self.len(){return None;}self.inner.at(self.inner.locate(index))}pub fn modify(&mut self,index:usize,f:impl FnOnce(&M::T)->M::T){assert!(index<self.len());let(i,j)=self.inner.locate(index);let Bucket{values,state}=&mut self.inner.buckets[i];values[j]=f(&values[j]);*state=FoldState::new(values);}pub fn insert(&mut self,index:usize,value:M::T){assert!(index<=self.len());self.inner.insert(self.inner.locate(index),value);}pub fn remove(&mut self,index:usize)->M::T{assert!(index<self.len());self.inner.remove(self.inner.locate(index))}pub fn push(&mut self,value:M::T){self.inner.insert((self.inner.buckets.len(),0),value);}pub fn pop(&mut self)->Option<M::T>{let i=self.inner.buckets.len().checked_sub(1)?;Some(self.inner.remove((i,self.inner.buckets[i].values.len()-1)))}pub fn iter(&self)->impl DoubleEndedIterator<Item=&M::T>{self.inner.buckets.iter().flat_map(|b|b.values.iter())}pub fn fold<R>(&self,range:R)->M::T where R:RangeBounds<usize>{let range=range.to_range_bounded(0,self.len()).expect("invalid range");self.inner.fold(range)}}impl<M>Default for SqrtFoldVec<M>where M:Monoid{fn default()->Self{Self::new()}}impl<M>FromIterator<M::T>for SqrtFoldVec<M>where M:Monoid{fn from_iter<I>(iter:I)->Self where I:IntoIterator<Item=M::T>{let values:Vec<_>=iter.into_iter().collect();Self{inner:Buckets::build(values.len(),values.into_iter())}}}impl<M>Extend<M::T>for SqrtFoldVec<M>where M:Monoid{fn extend<I>(&mut self,iter:I)where I:IntoIterator<Item=M::T>{for value in iter{self.push(value);}}}#[doc=" An ordered map with value aggregation in key order and no lazy updates."]#[doc=" Key lookup takes O(log N); folds and amortized updates take O(sqrt(N)) for O(1) monoid operations."]pub struct SqrtFoldMap<K,M>where M:Monoid{inner:Buckets<(K,M::T),FoldState<M,MapValue>>}impl<K,M>SqrtFoldMap<K,M>where M:Monoid{pub fn new()->Self{Self{inner:Buckets::new()}}pub fn len(&self)->usize{self.inner.len}pub fn is_empty(&self)->bool{self.len()==0}pub fn clear(&mut self){*self=Self::new();}pub fn get<Q>(&self,key:&Q)->Option<&M::T>where K:Borrow<Q>,Q:Ord+?Sized{self.get_key_value(key).map(|(_,v)|v)}pub fn get_key_value<Q>(&self,key:&Q)->Option<(&K,&M::T)>where K:Borrow<Q>,Q:Ord+?Sized{let p=self.inner.partition_point(|(k,_)|k.borrow()<key);self.inner.at(p).filter(|(k,_)|k.borrow()==key).map(|(k,v)|(k,v))}pub fn contains_key<Q>(&self,key:&Q)->bool where K:Borrow<Q>,Q:Ord+?Sized{self.get(key).is_some()}pub fn get_key_value_at(&self,index:usize)->Option<(&K,&M::T)>{if index>=self.len(){return None;}self.inner.at(self.inner.locate(index)).map(|(k,v)|(k,v))}pub fn insert(&mut self,key:K,value:M::T)->Option<M::T>where K:Ord{let(i,j)=self.inner.partition_point(|(k,_)|k<&key);if self.inner.at((i,j)).is_some_and(|(k,_)|k==&key){let Bucket{values,state}=&mut self.inner.buckets[i];let old=mem::replace(&mut values[j].1,value);*state=FoldState::new(values);return Some(old);}self.inner.insert((i,j),(key,value));None}#[doc=" Returns whether the key was present."]pub fn modify<Q>(&mut self,key:&Q,f:impl FnOnce(&M::T)->M::T)->bool where K:Borrow<Q>,Q:Ord+?Sized{let(i,j)=self.inner.partition_point(|(k,_)|k.borrow()<key);if!self.inner.at((i,j)).is_some_and(|(k,_)|k.borrow()==key){return false;}let Bucket{values,state}=&mut self.inner.buckets[i];values[j].1=f(&values[j].1);*state=FoldState::new(values);true}pub fn remove<Q>(&mut self,key:&Q)->Option<M::T>where K:Borrow<Q>,Q:Ord+?Sized{self.remove_entry(key).map(|(_,v)|v)}pub fn remove_entry<Q>(&mut self,key:&Q)->Option<(K,M::T)>where K:Borrow<Q>,Q:Ord+?Sized{let p=self.inner.partition_point(|(k,_)|k.borrow()<key);self.inner.at(p).filter(|(k,_)|k.borrow()==key)?;Some(self.inner.remove(p))}pub fn remove_at(&mut self,index:usize)->Option<(K,M::T)>{(index<self.len()).then(| |self.inner.remove(self.inner.locate(index)))}#[doc=" Counts keys strictly less than `key`."]pub fn rank<Q>(&self,key:&Q)->usize where K:Borrow<Q>,Q:Ord+?Sized{self.inner.position(self.inner.partition_point(|(k,_)|k.borrow()<key))}#[doc=" Counts keys less than or equal to `key`."]pub fn rank_le<Q>(&self,key:&Q)->usize where K:Borrow<Q>,Q:Ord+?Sized{self.inner.position(self.inner.partition_point(|(k,_)|k.borrow()<=key))}pub fn iter(&self)->impl DoubleEndedIterator<Item=(&K,&M::T)>{self.inner.buckets.iter().flat_map(|b|b.values.iter().map(|(k,v)|(k,v)))}pub fn fold<Q,R>(&self,range:R)->M::T where K:Borrow<Q>,Q:Ord+?Sized,R:RangeBounds<Q>{let(start,end)=self.inner.bounds(range,|(k,_)|k.borrow());self.inner.fold(self.inner.position(start)..self.inner.position(end))}}impl<K,M>Default for SqrtFoldMap<K,M>where M:Monoid{fn default()->Self{Self::new()}}impl<K,M>FromIterator<(K,M::T)>for SqrtFoldMap<K,M>where K:Ord,M:Monoid{fn from_iter<I>(iter:I)->Self where I:IntoIterator<Item=(K,M::T)>{let mut values:Vec<_>=iter.into_iter().collect();sort_dedup_map(&mut values);Self{inner:Buckets::build(values.len(),values.into_iter())}}}impl<K,M>Extend<(K,M::T)>for SqrtFoldMap<K,M>where K:Ord,M:Monoid{fn extend<I>(&mut self,iter:I)where I:IntoIterator<Item=(K,M::T)>{for(k,v)in iter{self.insert(k,v);}}}}mod lazy{use super::{Bucket,BucketState,BucketValue,Buckets,LazyMapAct,LazyMapAgg,LazyMapMonoidWithKeyAct,MapValue,RangeBoundsExt,SequenceValue,sort_dedup_map};use std::{borrow::Borrow,marker::PhantomData,mem,ops::{Range,RangeBounds}};struct LazyState<L,P>where L:LazyMapMonoidWithKeyAct{agg:LazyMapAgg<L>,act:LazyMapAct<L>,_marker:PhantomData<fn()->P>}impl<T,L,P>BucketState<T>for LazyState<L,P>where L:LazyMapMonoidWithKeyAct,P:BucketValue<T,Value=L::Key>{fn new(values:&[T])->Self{let agg=values.iter().fold(L::agg_unit(),|agg,value|{L::agg_operate(&agg,&L::single_agg(P::get(value)))});Self{agg,act:L::act_unit(),_marker:PhantomData}}fn push(&mut self,values:&mut[T]){if!L::is_act_unit(&self.act){for value in values{let value=P::get_mut(value);*value=L::act_key(value,&self.act);}self.act=L::act_unit();}}}impl<T,L,P>Buckets<T,LazyState<L,P>>where L:LazyMapMonoidWithKeyAct,P:BucketValue<T,Value=L::Key>{fn fold(&mut self,range:Range<usize>)->LazyMapAgg<L>{let mut result=L::agg_unit();assert!(range.start<=range.end);if range.is_empty(){return result;}let mut offset=0;for Bucket{values,state}in&mut self.buckets{let end=offset+values.len();if range.end<=offset{break;}if range.start<=offset&&end<=range.end{L::agg_operate_assign(&mut result,&state.agg);}else if range.start<end{state.push(values);for value in&values[range.start.saturating_sub(offset)..range.end.min(end)-offset]{L::agg_operate_assign(&mut result,&L::single_agg(P::get(value)));}}offset=end;}result}fn update(&mut self,range:Range<usize>,act:LazyMapAct<L>){assert!(range.start<=range.end);if range.is_empty()||L::is_act_unit(&act){return;}let mut offset=0;for Bucket{values,state}in&mut self.buckets{let end=offset+values.len();if range.end<=offset{break;}if range.start<=offset&&end<=range.end&&let Some(agg)=L::act_agg(&state.agg,&act){state.agg=agg;L::act_operate_assign(&mut state.act,&act);offset=end;continue;}if range.start<end{state.push(values);for value in&mut values[range.start.saturating_sub(offset)..range.end.min(end)-offset]{let value=P::get_mut(value);*value=L::act_key(value,&act);}*state=LazyState::new(values);}offset=end;}}}#[doc=" A dynamic sequence with ordered range aggregation and lazy range updates."]#[doc=" With O(1) monoid operations and successful `act_agg`, range operations take O(sqrt(N))."]#[doc=" An `act_agg` returning `None` materializes that bucket; updates can then take O(N)."]pub struct SqrtLazyVec<L>where L:LazyMapMonoidWithKeyAct{inner:Buckets<L::Key,LazyState<L,SequenceValue>>}impl<L>SqrtLazyVec<L>where L:LazyMapMonoidWithKeyAct{pub fn new()->Self{Self{inner:Buckets::new()}}pub fn len(&self)->usize{self.inner.len}pub fn is_empty(&self)->bool{self.len()==0}pub fn clear(&mut self){*self=Self::new();}pub fn get(&mut self,index:usize)->Option<&L::Key>{if index>=self.len(){return None;}let(i,j)=self.inner.locate(index);let Bucket{values,state}=&mut self.inner.buckets[i];state.push(values);Some(&values[j])}pub fn modify(&mut self,index:usize,f:impl FnOnce(&L::Key)->L::Key){assert!(index<self.len());let(i,j)=self.inner.locate(index);let Bucket{values,state}=&mut self.inner.buckets[i];state.push(values);values[j]=f(&values[j]);*state=LazyState::new(values);}pub fn insert(&mut self,index:usize,value:L::Key){assert!(index<=self.len());self.inner.insert(self.inner.locate(index),value);}pub fn remove(&mut self,index:usize)->L::Key{assert!(index<self.len());self.inner.remove(self.inner.locate(index))}pub fn push(&mut self,value:L::Key){self.inner.insert((self.inner.buckets.len(),0),value);}pub fn pop(&mut self)->Option<L::Key>{let i=self.inner.buckets.len().checked_sub(1)?;Some(self.inner.remove((i,self.inner.buckets[i].values.len()-1)))}#[doc=" Materializes pending updates before borrowing the elements."]pub fn iter(&mut self)->impl DoubleEndedIterator<Item=&L::Key>{for bucket in&mut self.inner.buckets{bucket.state.push(&mut bucket.values);}self.inner.buckets.iter().flat_map(|b|b.values.iter())}pub fn fold<R>(&mut self,range:R)->LazyMapAgg<L>where R:RangeBounds<usize>{let range=range.to_range_bounded(0,self.len()).expect("invalid range");self.inner.fold(range)}pub fn update<R>(&mut self,range:R,act:LazyMapAct<L>)where R:RangeBounds<usize>{let range=range.to_range_bounded(0,self.len()).expect("invalid range");self.inner.update(range,act);}}impl<L>Default for SqrtLazyVec<L>where L:LazyMapMonoidWithKeyAct{fn default()->Self{Self::new()}}impl<L>FromIterator<L::Key>for SqrtLazyVec<L>where L:LazyMapMonoidWithKeyAct{fn from_iter<I>(iter:I)->Self where I:IntoIterator<Item=L::Key>{let values:Vec<_>=iter.into_iter().collect();Self{inner:Buckets::build(values.len(),values.into_iter())}}}impl<L>Extend<L::Key>for SqrtLazyVec<L>where L:LazyMapMonoidWithKeyAct{fn extend<I>(&mut self,iter:I)where I:IntoIterator<Item=L::Key>{for value in iter{self.push(value);}}}#[doc=" An ordered map aggregating and updating values in key order, without changing keys."]#[doc=" Value access can materialize a bucket and takes O(sqrt(N))."]#[doc=" Range operations have the same costs and `act_agg` fallback as `SqrtLazyVec`."]pub struct SqrtLazyMap<K,L>where L:LazyMapMonoidWithKeyAct{inner:Buckets<(K,L::Key),LazyState<L,MapValue>>}impl<K,L>SqrtLazyMap<K,L>where L:LazyMapMonoidWithKeyAct{pub fn new()->Self{Self{inner:Buckets::new()}}pub fn len(&self)->usize{self.inner.len}pub fn is_empty(&self)->bool{self.len()==0}pub fn clear(&mut self){*self=Self::new();}pub fn contains_key<Q>(&self,key:&Q)->bool where K:Borrow<Q>,Q:Ord+?Sized{let p=self.inner.partition_point(|(k,_)|k.borrow()<key);self.inner.at(p).is_some_and(|(k,_)|k.borrow()==key)}pub fn get<Q>(&mut self,key:&Q)->Option<&L::Key>where K:Borrow<Q>,Q:Ord+?Sized{self.get_key_value(key).map(|(_,v)|v)}pub fn get_key_value<Q>(&mut self,key:&Q)->Option<(&K,&L::Key)>where K:Borrow<Q>,Q:Ord+?Sized{let(i,j)=self.inner.partition_point(|(k,_)|k.borrow()<key);self.inner.at((i,j)).filter(|(k,_)|k.borrow()==key)?;let Bucket{values,state}=&mut self.inner.buckets[i];state.push(values);let(k,v)=&values[j];Some((k,v))}pub fn get_key_value_at(&mut self,index:usize)->Option<(&K,&L::Key)>{if index>=self.len(){return None;}let(i,j)=self.inner.locate(index);let Bucket{values,state}=&mut self.inner.buckets[i];state.push(values);let(k,v)=&values[j];Some((k,v))}pub fn insert(&mut self,key:K,value:L::Key)->Option<L::Key>where K:Ord{let(i,j)=self.inner.partition_point(|(k,_)|k<&key);if self.inner.at((i,j)).is_some_and(|(k,_)|k==&key){let Bucket{values,state}=&mut self.inner.buckets[i];state.push(values);let old=mem::replace(&mut values[j].1,value);*state=LazyState::new(values);return Some(old);}self.inner.insert((i,j),(key,value));None}#[doc=" Returns whether the key was present."]pub fn modify<Q>(&mut self,key:&Q,f:impl FnOnce(&L::Key)->L::Key)->bool where K:Borrow<Q>,Q:Ord+?Sized{let(i,j)=self.inner.partition_point(|(k,_)|k.borrow()<key);if!self.inner.at((i,j)).is_some_and(|(k,_)|k.borrow()==key){return false;}let Bucket{values,state}=&mut self.inner.buckets[i];state.push(values);values[j].1=f(&values[j].1);*state=LazyState::new(values);true}pub fn remove<Q>(&mut self,key:&Q)->Option<L::Key>where K:Borrow<Q>,Q:Ord+?Sized{self.remove_entry(key).map(|(_,v)|v)}pub fn remove_entry<Q>(&mut self,key:&Q)->Option<(K,L::Key)>where K:Borrow<Q>,Q:Ord+?Sized{let p=self.inner.partition_point(|(k,_)|k.borrow()<key);self.inner.at(p).filter(|(k,_)|k.borrow()==key)?;Some(self.inner.remove(p))}pub fn remove_at(&mut self,index:usize)->Option<(K,L::Key)>{(index<self.len()).then(| |self.inner.remove(self.inner.locate(index)))}#[doc=" Counts keys strictly less than `key`."]pub fn rank<Q>(&self,key:&Q)->usize where K:Borrow<Q>,Q:Ord+?Sized{self.inner.position(self.inner.partition_point(|(k,_)|k.borrow()<key))}#[doc=" Counts keys less than or equal to `key`."]pub fn rank_le<Q>(&self,key:&Q)->usize where K:Borrow<Q>,Q:Ord+?Sized{self.inner.position(self.inner.partition_point(|(k,_)|k.borrow()<=key))}#[doc=" Materializes pending updates before borrowing the entries."]pub fn iter(&mut self)->impl DoubleEndedIterator<Item=(&K,&L::Key)>{for bucket in&mut self.inner.buckets{bucket.state.push(&mut bucket.values);}self.inner.buckets.iter().flat_map(|b|b.values.iter().map(|(k,v)|(k,v)))}pub fn fold<Q,R>(&mut self,range:R)->LazyMapAgg<L>where K:Borrow<Q>,Q:Ord+?Sized,R:RangeBounds<Q>{let(start,end)=self.inner.bounds(range,|(k,_)|k.borrow());let range=self.inner.position(start)..self.inner.position(end);self.inner.fold(range)}pub fn update<Q,R>(&mut self,range:R,act:LazyMapAct<L>)where K:Borrow<Q>,Q:Ord+?Sized,R:RangeBounds<Q>{let(start,end)=self.inner.bounds(range,|(k,_)|k.borrow());let range=self.inner.position(start)..self.inner.position(end);self.inner.update(range,act);}}impl<K,L>Default for SqrtLazyMap<K,L>where L:LazyMapMonoidWithKeyAct{fn default()->Self{Self::new()}}impl<K,L>FromIterator<(K,L::Key)>for SqrtLazyMap<K,L>where K:Ord,L:LazyMapMonoidWithKeyAct{fn from_iter<I>(iter:I)->Self where I:IntoIterator<Item=(K,L::Key)>{let mut values:Vec<_>=iter.into_iter().collect();sort_dedup_map(&mut values);Self{inner:Buckets::build(values.len(),values.into_iter())}}}impl<K,L>Extend<(K,L::Key)>for SqrtLazyMap<K,L>where K:Ord,L:LazyMapMonoidWithKeyAct{fn extend<I>(&mut self,iter:I)where I:IntoIterator<Item=(K,L::Key)>{for(k,v)in iter{self.insert(k,v);}}}}mod plain{use super::{Bucket,Buckets,sort_dedup_map};use std::{borrow::Borrow,fmt::{self,Debug},iter::FusedIterator,mem,ops::RangeBounds};impl<T>Buckets<T,()>{fn range<Q,R>(&self,range:R,key:impl Fn(&T)->&Q)->SqrtIter<'_,T>where Q:Ord+?Sized,R:RangeBounds<Q>{let(front,back)=self.bounds(range,key);SqrtIter{buckets:&self.buckets,front,back}}}#[doc=" A sequence with amortized O(sqrt(N)) insertion/removal and O(sqrt(N)) indexing."]#[doc=" An individual insertion or removal can take O(N) when rebuilding."]#[derive(Clone)]pub struct SqrtVec<T>{inner:Buckets<T,()>}impl<T>SqrtVec<T>{pub fn new()->Self{Self{inner:Buckets::new()}}pub fn len(&self)->usize{self.inner.len}pub fn is_empty(&self)->bool{self.len()==0}pub fn clear(&mut self){*self=Self::new();}pub fn get(&self,index:usize)->Option<&T>{if index>=self.len(){return None;}self.inner.at(self.inner.locate(index))}pub fn get_mut(&mut self,index:usize)->Option<&mut T>{if index>=self.len(){return None;}let(i,j)=self.inner.locate(index);Some(&mut self.inner.buckets[i].values[j])}pub fn first(&self)->Option<&T>{self.inner.buckets.first()?.values.first()}pub fn last(&self)->Option<&T>{self.inner.buckets.last()?.values.last()}pub fn insert(&mut self,index:usize,value:T){assert!(index<=self.len());self.inner.insert(self.inner.locate(index),value);}pub fn remove(&mut self,index:usize)->T{assert!(index<self.len());self.inner.remove(self.inner.locate(index))}pub fn push(&mut self,value:T){self.inner.insert((self.inner.buckets.len(),0),value);}pub fn pop(&mut self)->Option<T>{let i=self.inner.buckets.len().checked_sub(1)?;Some(self.inner.remove((i,self.inner.buckets[i].values.len()-1)))}pub fn iter(&self)->SqrtIter<'_,T>{SqrtIter{buckets:&self.inner.buckets,front:(0,0),back:(self.inner.buckets.len(),0)}}pub fn iter_mut(&mut self)->impl DoubleEndedIterator<Item=&mut T>{self.inner.buckets.iter_mut().flat_map(|b|b.values.iter_mut())}}impl<T>Default for SqrtVec<T>{fn default()->Self{Self::new()}}impl<T>FromIterator<T>for SqrtVec<T>{fn from_iter<I>(iter:I)->Self where I:IntoIterator<Item=T>{let values:Vec<_>=iter.into_iter().collect();Self{inner:Buckets::build(values.len(),values.into_iter())}}}impl<T>Extend<T>for SqrtVec<T>{fn extend<I>(&mut self,iter:I)where I:IntoIterator<Item=T>{for value in iter{self.push(value);}}}impl<T>Debug for SqrtVec<T>where T:Debug{fn fmt(&self,f:&mut fmt::Formatter<'_>)->fmt::Result{f.debug_list().entries(self.iter()).finish()}}impl<T>PartialEq for SqrtVec<T>where T:PartialEq{fn eq(&self,other:&Self)->bool{self.len()==other.len()&&self.iter().eq(other.iter())}}impl<T>Eq for SqrtVec<T>where T:Eq{}impl<T>IntoIterator for SqrtVec<T>{type Item=T;type IntoIter=SqrtIntoIter<T>;fn into_iter(self)->Self::IntoIter{SqrtIntoIter{buckets:self.inner.buckets.into_iter(),front:Vec::new().into_iter(),back:Vec::new().into_iter(),remaining:self.inner.len}}}impl<'a,T>IntoIterator for&'a SqrtVec<T>{type Item=&'a T;type IntoIter=SqrtIter<'a,T>;fn into_iter(self)->Self::IntoIter{self.iter()}}#[derive(Debug)]pub struct SqrtIter<'a,T>{buckets:&'a[Bucket<T,()>],front:(usize,usize),back:(usize,usize)}impl<T>Clone for SqrtIter<'_,T>{fn clone(&self)->Self{Self{buckets:self.buckets,front:self.front,back:self.back}}}impl<'a,T>Iterator for SqrtIter<'a,T>{type Item=&'a T;fn next(&mut self)->Option<Self::Item>{if self.front>=self.back{return None;}let(i,j)=self.front;let values=&self.buckets[i].values;self.front=if j+1==values.len(){(i+1,0)}else{(i,j+1)};Some(&values[j])}}impl<T>DoubleEndedIterator for SqrtIter<'_,T>{fn next_back(&mut self)->Option<Self::Item>{if self.front>=self.back{return None;}if self.back.1==0{self.back.0-=1;self.back.1=self.buckets[self.back.0].values.len();}self.back.1-=1;Some(&self.buckets[self.back.0].values[self.back.1])}}impl<T>FusedIterator for SqrtIter<'_,T>{}#[derive(Clone,Debug)]pub struct SqrtIntoIter<T>{buckets:std::vec::IntoIter<Bucket<T,()>>,front:std::vec::IntoIter<T>,back:std::vec::IntoIter<T>,remaining:usize}impl<T>Iterator for SqrtIntoIter<T>{type Item=T;fn next(&mut self)->Option<T>{let value=loop{if let Some(value)=self.front.next(){break Some(value);}if let Some(bucket)=self.buckets.next(){self.front=bucket.values.into_iter();}else{break self.back.next();}};self.remaining-=usize::from(value.is_some());value}fn size_hint(&self)->(usize,Option<usize>){(self.remaining,Some(self.remaining))}}impl<T>DoubleEndedIterator for SqrtIntoIter<T>{fn next_back(&mut self)->Option<T>{let value=loop{if let Some(value)=self.back.next_back(){break Some(value);}if let Some(bucket)=self.buckets.next_back(){self.back=bucket.values.into_iter();}else{break self.front.next_back();}};self.remaining-=usize::from(value.is_some());value}}impl<T>ExactSizeIterator for SqrtIntoIter<T>{}impl<T>FusedIterator for SqrtIntoIter<T>{}macro_rules!sqrt_set{($name:ident,$doc:literal)=>{#[doc=$doc]#[derive(Clone,Debug,PartialEq,Eq)]pub struct$name<T>{inner:SqrtVec<T>,}impl<T>$name<T>{pub fn new()->Self{Self{inner:SqrtVec::new(),}}pub fn len(&self)->usize{self.inner.len()}pub fn is_empty(&self)->bool{self.inner.is_empty()}pub fn clear(&mut self){self.inner.clear();}pub fn iter(&self)->SqrtIter<'_,T>{self.inner.iter()}pub fn first(&self)->Option<&T>{self.inner.first()}pub fn last(&self)->Option<&T>{self.inner.last()}pub fn get_at(&self,index:usize)->Option<&T>{self.inner.get(index)}pub fn remove_at(&mut self,index:usize)->Option<T>{(index<self.len()).then(||self.inner.remove(index))}pub fn get<Q>(&self,key:&Q)->Option<&T>where T:Borrow<Q>,Q:Ord+?Sized,{let p=self.inner.inner.partition_point(|v|v.borrow()<key);self.inner.inner.at(p).filter(|v|<T as Borrow<Q>>::borrow(v)==key)}pub fn contains<Q>(&self,key:&Q)->bool where T:Borrow<Q>,Q:Ord+?Sized,{self.get(key).is_some()}#[doc=" Removes one occurrence and returns whether it was present."]pub fn remove<Q>(&mut self,key:&Q)->bool where T:Borrow<Q>,Q:Ord+?Sized,{let p=self.inner.inner.partition_point(|v|v.borrow()<key);if self.inner.inner.at(p).is_some_and(|v|v.borrow()==key){self.inner.inner.remove(p);true}else{false}}#[doc=" Counts elements strictly less than `key`."]pub fn rank<Q>(&self,key:&Q)->usize where T:Borrow<Q>,Q:Ord+?Sized,{self.inner.inner.position(self.inner.inner.partition_point(|v|v.borrow()<key))}#[doc=" Counts elements less than or equal to `key`."]pub fn rank_le<Q>(&self,key:&Q)->usize where T:Borrow<Q>,Q:Ord+?Sized,{self.inner.inner.position(self.inner.inner.partition_point(|v|v.borrow()<=key))}pub fn range<Q,R>(&self,range:R)->SqrtIter<'_,T>where T:Borrow<Q>,Q:Ord+?Sized,R:RangeBounds<Q>,{self.inner.inner.range(range,|v|v.borrow())}}impl<T>Default for$name<T>{fn default()->Self{Self::new()}}impl<T>Extend<T>for$name<T>where T:Ord,{fn extend<I>(&mut self,iter:I)where I:IntoIterator<Item=T>,{for value in iter{self.insert(value);}}}impl<T>IntoIterator for$name<T>{type Item=T;type IntoIter=SqrtIntoIter<T>;fn into_iter(self)->Self::IntoIter{self.inner.into_iter()}}impl<'a,T>IntoIterator for&'a$name<T>{type Item=&'a T;type IntoIter=SqrtIter<'a,T>;fn into_iter(self)->Self::IntoIter{self.iter()}}};}sqrt_set!(SqrtSet,"An ordered set with O(log N) key lookup and amortized O(sqrt(N)) updates. Rank and indexing take O(sqrt(N)).");sqrt_set!(SqrtMultiset,"An ordered multiset. Length, rank and indexing count duplicate elements. Complexity matches `SqrtSet`.");impl<T>SqrtSet<T>{pub fn insert(&mut self,value:T)->bool where T:Ord{let p=self.inner.inner.partition_point(|v|v<&value);if self.inner.inner.at(p)==Some(&value){return false;}self.inner.inner.insert(p,value);true}}impl<T>FromIterator<T>for SqrtSet<T>where T:Ord{fn from_iter<I>(iter:I)->Self where I:IntoIterator<Item=T>{let mut values:Vec<_>=iter.into_iter().collect();values.sort_unstable();values.dedup();Self{inner:SqrtVec{inner:Buckets::build(values.len(),values.into_iter())}}}}impl<T>SqrtMultiset<T>{pub fn insert(&mut self,value:T)where T:Ord{let p=self.inner.inner.partition_point(|v|v<=&value);self.inner.inner.insert(p,value);}pub fn count<Q>(&self,key:&Q)->usize where T:Borrow<Q>,Q:Ord+?Sized{self.rank_le(key)-self.rank(key)}}impl<T>FromIterator<T>for SqrtMultiset<T>where T:Ord{fn from_iter<I>(iter:I)->Self where I:IntoIterator<Item=T>{let mut values:Vec<_>=iter.into_iter().collect();values.sort_unstable();Self{inner:SqrtVec{inner:Buckets::build(values.len(),values.into_iter())}}}}#[doc=" An ordered map with O(log N) key lookup and amortized O(sqrt(N)) updates."]#[doc=" Rank and indexing take O(sqrt(N))."]#[derive(Clone,Debug,PartialEq,Eq)]pub struct SqrtMap<K,V>{inner:SqrtVec<(K,V)>}impl<K,V>SqrtMap<K,V>{pub fn new()->Self{Self{inner:SqrtVec::new()}}pub fn len(&self)->usize{self.inner.len()}pub fn is_empty(&self)->bool{self.inner.is_empty()}pub fn clear(&mut self){self.inner.clear();}pub fn iter(&self)->impl DoubleEndedIterator<Item=(&K,&V)>{self.inner.iter().map(|(k,v)|(k,v))}pub fn iter_mut(&mut self)->impl DoubleEndedIterator<Item=(&K,&mut V)>{self.inner.iter_mut().map(|(k,v)|(&*k,v))}pub fn get_key_value_at(&self,index:usize)->Option<(&K,&V)>{self.inner.get(index).map(|(k,v)|(k,v))}pub fn remove_at(&mut self,index:usize)->Option<(K,V)>{(index<self.len()).then(| |self.inner.remove(index))}pub fn first_key_value(&self)->Option<(&K,&V)>{self.inner.first().map(|(k,v)|(k,v))}pub fn last_key_value(&self)->Option<(&K,&V)>{self.inner.last().map(|(k,v)|(k,v))}pub fn get<Q>(&self,key:&Q)->Option<&V>where K:Borrow<Q>,Q:Ord+?Sized{self.get_key_value(key).map(|(_,v)|v)}pub fn get_key_value<Q>(&self,key:&Q)->Option<(&K,&V)>where K:Borrow<Q>,Q:Ord+?Sized{let p=self.inner.inner.partition_point(|(k,_)|k.borrow()<key);self.inner.inner.at(p).filter(|(k,_)|k.borrow()==key).map(|(k,v)|(k,v))}pub fn get_mut<Q>(&mut self,key:&Q)->Option<&mut V>where K:Borrow<Q>,Q:Ord+?Sized{let(i,j)=self.inner.inner.partition_point(|(k,_)|k.borrow()<key);let(k,v)=self.inner.inner.buckets.get_mut(i)?.values.get_mut(j)?;(<K as Borrow<Q>>::borrow(k)==key).then_some(v)}pub fn contains_key<Q>(&self,key:&Q)->bool where K:Borrow<Q>,Q:Ord+?Sized{self.get(key).is_some()}pub fn insert(&mut self,key:K,value:V)->Option<V>where K:Ord{let(i,j)=self.inner.inner.partition_point(|(k,_)|k<&key);if self.inner.inner.at((i,j)).is_some_and(|(k,_)|k==&key){return Some(mem::replace(&mut self.inner.inner.buckets[i].values[j].1,value));}self.inner.inner.insert((i,j),(key,value));None}pub fn remove<Q>(&mut self,key:&Q)->Option<V>where K:Borrow<Q>,Q:Ord+?Sized{self.remove_entry(key).map(|(_,v)|v)}pub fn remove_entry<Q>(&mut self,key:&Q)->Option<(K,V)>where K:Borrow<Q>,Q:Ord+?Sized{let p=self.inner.inner.partition_point(|(k,_)|k.borrow()<key);self.inner.inner.at(p).filter(|(k,_)|k.borrow()==key)?;Some(self.inner.inner.remove(p))}#[doc=" Counts keys strictly less than `key`."]pub fn rank<Q>(&self,key:&Q)->usize where K:Borrow<Q>,Q:Ord+?Sized{self.inner.inner.position(self.inner.inner.partition_point(|(k,_)|k.borrow()<key))}#[doc=" Counts keys less than or equal to `key`."]pub fn rank_le<Q>(&self,key:&Q)->usize where K:Borrow<Q>,Q:Ord+?Sized{self.inner.inner.position(self.inner.inner.partition_point(|(k,_)|k.borrow()<=key))}pub fn range<Q,R>(&self,range:R)->impl DoubleEndedIterator<Item=(&K,&V)>where K:Borrow<Q>,Q:Ord+?Sized,R:RangeBounds<Q>{self.inner.inner.range(range,|(k,_)|k.borrow()).map(|(k,v)|(k,v))}}impl<K,V>Default for SqrtMap<K,V>{fn default()->Self{Self::new()}}impl<K,V>FromIterator<(K,V)>for SqrtMap<K,V>where K:Ord{fn from_iter<I>(iter:I)->Self where I:IntoIterator<Item=(K,V)>{let mut values:Vec<_>=iter.into_iter().collect();sort_dedup_map(&mut values);Self{inner:SqrtVec{inner:Buckets::build(values.len(),values.into_iter())}}}}impl<K,V>Extend<(K,V)>for SqrtMap<K,V>where K:Ord{fn extend<I>(&mut self,iter:I)where I:IntoIterator<Item=(K,V)>{for(k,v)in iter{self.insert(k,v);}}}impl<K,V>IntoIterator for SqrtMap<K,V>{type Item=(K,V);type IntoIter=SqrtIntoIter<(K,V)>;fn into_iter(self)->Self::IntoIter{self.inner.into_iter()}}}trait BucketState<T>:Sized{fn new(values:&[T])->Self;fn push(&mut self,values:&mut[T]);}impl<T>BucketState<T>for(){fn new(_:&[T])->Self{}fn push(&mut self,_:&mut[T]){}}#[derive(Clone,Debug)]struct Bucket<T,S>{values:Vec<T>,state:S}#[derive(Clone,Debug)]struct Buckets<T,S>{buckets:Vec<Bucket<T,S>>,sizes:Vec<usize>,len:usize,base_len:usize,bucket_size:usize}impl<T,S>Buckets<T,S>where S:BucketState<T>{fn new()->Self{Self{buckets:Vec::new(),sizes:Vec::new(),len:0,base_len:0,bucket_size:1}}fn build(len:usize,mut values:impl Iterator<Item=T>)->Self{if len==0{return Self::new();}let bucket_size=(len-1).isqrt()+1;let mut buckets=Vec::with_capacity(len.div_ceil(bucket_size));let mut sizes=Vec::with_capacity(len.div_ceil(bucket_size));while let Some(first)=values.next(){let mut chunk=Vec::with_capacity(bucket_size);chunk.push(first);chunk.extend(values.by_ref().take(bucket_size-1));sizes.push(chunk.len());let state=S::new(&chunk);buckets.push(Bucket{values:chunk,state});}Self{buckets,sizes,len,base_len:len,bucket_size}}fn locate(&self,mut index:usize)->(usize,usize){if index>=self.len/2{index=self.len-index;for(i,&size)in self.sizes.iter().enumerate().rev(){if index<=size{return(i,size-index);}index-=size;}return(0,0);}for(i,&size)in self.sizes.iter().enumerate(){if index<size{return(i,index);}index-=size;}(self.buckets.len(),0)}fn insert(&mut self,(mut i,mut j):(usize,usize),value:T){if self.len==0{*self=Self::build(1,std::iter::once(value));return;}if i==self.buckets.len(){i-=1;j=self.buckets[i].values.len();}let Bucket{values,state}=&mut self.buckets[i];state.push(values);values.insert(j,value);self.sizes[i]+=1;if values.len()>2*self.bucket_size{let right=values.split_off(values.len()/2);self.sizes[i]=values.len();self.sizes.insert(i+1,right.len());*state=S::new(values);let state=S::new(&right);self.buckets.insert(i+1,Bucket{values:right,state});}else{*state=S::new(values);}self.len+=1;self.rebuild_if_needed();}fn remove(&mut self,(i,j):(usize,usize))->T{let Bucket{values,state}=&mut self.buckets[i];state.push(values);let value=values.remove(j);self.sizes[i]-=1;if values.is_empty(){self.buckets.remove(i);self.sizes.remove(i);}else{*state=S::new(values);}self.len-=1;self.rebuild_if_needed();value}fn rebuild_if_needed(&mut self){if self.len<self.base_len.div_ceil(2)||self.len>self.base_len.saturating_mul(2)||self.buckets.len()>2*self.base_len.div_ceil(self.bucket_size){let values=mem::take(&mut self.buckets).into_iter().flat_map(|mut bucket|{bucket.state.push(&mut bucket.values);bucket.values});*self=Self::build(self.len,values);}}fn partition_point(&self,mut before:impl FnMut(&T)->bool)->(usize,usize){let i=self.buckets.partition_point(|b|before(b.values.last().unwrap()));let j=self.buckets.get(i).map_or(0,|b|b.values.partition_point(before));(i,j)}fn position(&self,(i,j):(usize,usize))->usize{if i<self.buckets.len()/2{self.sizes[..i].iter().sum::<usize>()+j}else{self.len-self.sizes[i..].iter().sum::<usize>()+j}}fn at(&self,(i,j):(usize,usize))->Option<&T>{self.buckets.get(i).and_then(|b|b.values.get(j))}fn bounds<Q,R>(&self,range:R,key:impl Fn(&T)->&Q)->((usize,usize),(usize,usize))where Q:Ord+?Sized,R:RangeBounds<Q>{let start=range.start_bound();let end=range.end_bound();if let(Bound::Included(a)|Bound::Excluded(a),Bound::Included(b)|Bound::Excluded(b))=(start,end){assert!(a<=b&&!(a==b&&matches!((start,end),(Bound::Excluded(_),Bound::Excluded(_)))),"invalid range");}let front=match start{Bound::Unbounded=>(0,0),Bound::Included(x)=>self.partition_point(|v|key(v)<x),Bound::Excluded(x)=>self.partition_point(|v|key(v)<=x),};let back=match end{Bound::Unbounded=>(self.buckets.len(),0),Bound::Included(x)=>self.partition_point(|v|key(v)<=x),Bound::Excluded(x)=>self.partition_point(|v|key(v)<x),};(front,back)}}fn sort_dedup_map<K,V>(values:&mut Vec<(K,V)>)where K:Ord{values.sort_by(|a,b|a.0 .cmp(&b.0));values.dedup_by(|a,b|{if a.0==b.0{mem::swap(&mut a.1,&mut b.1);true}else{false}});}trait BucketValue<T>{type Value;fn get(value:&T)->&Self::Value;fn get_mut(value:&mut T)->&mut Self::Value;}struct SequenceValue;impl<T>BucketValue<T>for SequenceValue{type Value=T;fn get(value:&T)->&T{value}fn get_mut(value:&mut T)->&mut T{value}}struct MapValue;impl<K,V>BucketValue<(K,V)>for MapValue{type Value=V;fn get(value:&(K,V))->&V{&value.1}fn get_mut(value:&mut(K,V))->&mut V{&mut value.1}}}
// 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: ArrayOperation
#[cfg_attr(any(),rustfmt::skip)]pub use self::array_operation_impl::ArrayOperation;#[cfg_attr(any(),rustfmt::skip)]mod array_operation_impl{use super::*;use crate::array;use std::marker::PhantomData;pub struct ArrayOperation<M,const N:usize>{_marker:PhantomData<fn()->M>}impl<M,const N:usize>Magma for ArrayOperation<M,N>where M:Magma{type T=[M::T;N];#[inline]fn operate(x:&Self::T,y:&Self::T)->Self::T{array!(|i|M::operate(&x[i],&y[i]);N)}}impl<M,const N:usize>Unital for ArrayOperation<M,N>where M:Unital{#[inline]fn unit()->Self::T{array!(||M::unit();N)}}impl<M,const N:usize>Associative for ArrayOperation<M,N>where M:Associative{}impl<M,const N:usize>Commutative for ArrayOperation<M,N>where M:Commutative{}impl<M,const N:usize>Idempotent for ArrayOperation<M,N>where M:Idempotent{}impl<M,const N:usize>Invertible for ArrayOperation<M,N>where M:Invertible{#[inline]fn inverse(x:&Self::T)->Self::T{array!(|i|M::inverse(&x[i]);N)}}}
// codesnip-guard: CountingOperation
#[cfg_attr(any(),rustfmt::skip)]pub use self::counting_operation_impl::CountingOperation;#[cfg_attr(any(),rustfmt::skip)]mod counting_operation_impl{use super::*;use std::marker::PhantomData;pub struct CountingOperation<M>{_marker:PhantomData<fn()->M>}impl<M>Magma for CountingOperation<M>where M:Magma<T:PartialEq>+Idempotent{type T=(M::T,usize);#[inline]fn operate(x:&Self::T,y:&Self::T)->Self::T{let z=M::operate(&x.0,&y.0);match(z==x.0,z==y.0){(true,true)=>(z,x.1+y.1),(true,false)=>(z,x.1),(false,true)=>(z,y.1),(false,false)=>(z,1),}}}impl<M>Unital for CountingOperation<M>where M:Unital<T:PartialEq>+Idempotent{#[inline]fn unit()->Self::T{(M::unit(),0)}}impl<M>Associative for CountingOperation<M>where M:Associative<T:PartialEq>+Idempotent{}impl<M>Commutative for CountingOperation<M>where M:Commutative<T:PartialEq>+Idempotent{}}
// codesnip-guard: LastOperation
#[cfg_attr(any(),rustfmt::skip)]pub use self::last_operation_impl::LastOperation;#[cfg_attr(any(),rustfmt::skip)]mod last_operation_impl{use super::*;use std::marker::PhantomData;#[doc=" retain the last element"]pub struct LastOperation<T>where T:Clone{_marker:PhantomData<fn()->T>}impl<T>Magma for LastOperation<T>where T:Clone{type T=Option<T>;#[inline]fn operate(x:&Self::T,y:&Self::T)->Self::T{y.as_ref().or(x.as_ref()).cloned()}}impl<T>Unital for LastOperation<T>where T:Clone{#[inline]fn unit()->Self::T{None}}impl<T>Associative for LastOperation<T>where T:Clone{}impl<T>Idempotent for LastOperation<T>where T:Clone{}}
// codesnip-guard: LazyMapMonoid
#[cfg_attr(any(),rustfmt::skip)]pub use self::lazy_map::*;#[cfg_attr(any(),rustfmt::skip)]mod lazy_map{use super::*;use std::{cmp::Ordering,marker::PhantomData,ops::{Add,Mul,Sub}};pub type LazyMapAgg<L>=<<L as LazyMapMonoid>::AggMonoid as Magma>::T;pub type LazyMapAct<L>=<<L as LazyMapMonoid>::ActMonoid as Magma>::T;pub trait LazyMapMonoid{type Key;type AggMonoid:Monoid;type ActMonoid:Monoid<T:PartialEq>;fn single_agg(key:&Self::Key)->LazyMapAgg<Self>;fn toggle(_x:&mut LazyMapAgg<Self>){}#[inline]fn is_act_unit(act:&LazyMapAct<Self>)->bool{<Self::ActMonoid as Unital>::is_unit(act)}#[doc=" Returns `None` when descent is needed; must succeed on single-key aggregates."]fn act_agg(x:&LazyMapAgg<Self>,a:&LazyMapAct<Self>)->Option<LazyMapAgg<Self>>;#[inline]fn agg_unit()->LazyMapAgg<Self>{<Self::AggMonoid as Unital>::unit()}#[inline]fn act_unit()->LazyMapAct<Self>{<Self::ActMonoid as Unital>::unit()}#[inline]fn agg_operate(x:&LazyMapAgg<Self>,y:&LazyMapAgg<Self>)->LazyMapAgg<Self>{<Self::AggMonoid as Magma>::operate(x,y)}#[inline]fn act_operate(x:&LazyMapAct<Self>,y:&LazyMapAct<Self>)->LazyMapAct<Self>{<Self::ActMonoid as Magma>::operate(x,y)}#[inline]fn agg_operate_assign(x:&mut LazyMapAgg<Self>,y:&LazyMapAgg<Self>){*x=<Self::AggMonoid as Magma>::operate(x,y);}#[inline]fn act_operate_assign(x:&mut LazyMapAct<Self>,y:&LazyMapAct<Self>){*x=<Self::ActMonoid as Magma>::operate(x,y);}}pub trait LazyMapMonoidWithKeyAct:LazyMapMonoid{fn act_key(key:&Self::Key,act:&LazyMapAct<Self>)->Self::Key;}pub struct EmptyActLazy<M>{_marker:PhantomData<fn()->M>}impl<M>LazyMapMonoid for EmptyActLazy<M>where M:Monoid{type Key=M::T;type AggMonoid=M;type ActMonoid=();fn single_agg(key:&Self::Key)->LazyMapAgg<Self>{key.clone()}fn act_agg(x:&LazyMapAgg<Self>,_a:&LazyMapAct<Self>)->Option<LazyMapAgg<Self>>{Some(x.clone())}}impl<M>LazyMapMonoidWithKeyAct for EmptyActLazy<M>where M:Monoid{fn act_key(key:&Self::Key,act:&LazyMapAct<Self>)->Self::Key{EmptyAct::act(key,act)}}pub struct EmptyAggActLazy<T>{_marker:PhantomData<fn()->T>}impl<T>LazyMapMonoid for EmptyAggActLazy<T>{type Key=T;type AggMonoid=();type ActMonoid=();fn single_agg(_key:&Self::Key)->LazyMapAgg<Self>{}fn act_agg(_x:&LazyMapAgg<Self>,_a:&LazyMapAct<Self>)->Option<LazyMapAgg<Self>>{Some(())}}impl<T>LazyMapMonoidWithKeyAct for EmptyAggActLazy<T>where T:Clone{fn act_key(key:&Self::Key,act:&LazyMapAct<Self>)->Self::Key{EmptyAct::act(key,act)}}pub struct FlattenLazy<M>{_marker:PhantomData<fn()->M>}impl<M>LazyMapMonoid for FlattenLazy<M>where M:Monoid,M::T:PartialEq{type Key=M::T;type AggMonoid=M;type ActMonoid=M;fn single_agg(key:&Self::Key)->LazyMapAgg<Self>{key.clone()}fn act_agg(x:&LazyMapAgg<Self>,a:&LazyMapAct<Self>)->Option<LazyMapAgg<Self>>{Some(M::operate(x,a))}}impl<M>LazyMapMonoidWithKeyAct for FlattenLazy<M>where M:Monoid,M::T:PartialEq{fn act_key(key:&Self::Key,act:&LazyMapAct<Self>)->Self::Key{FlattenAct::<M>::act(key,act)}}pub struct RangeSumRangeAdd<T>{_marker:PhantomData<fn()->T>}impl<T>LazyMapMonoid for RangeSumRangeAdd<T>where T:Copy+Zero+One+Add<Output=T>+Mul<Output=T>+PartialEq{type Key=T;type AggMonoid=(AdditiveOperation<T>,AdditiveOperation<T>);type ActMonoid=AdditiveOperation<T>;fn single_agg(key:&Self::Key)->LazyMapAgg<Self>{(*key,T::one())}fn act_agg(&(x,y):&LazyMapAgg<Self>,a:&LazyMapAct<Self>)->Option<LazyMapAgg<Self>>{Some(if Self::is_act_unit(a){(x,y)}else{let a=*a;(x+a*y,y)})}}impl<T>LazyMapMonoidWithKeyAct for RangeSumRangeAdd<T>where T:Copy+Zero+One+Add<Output=T>+Mul<Output=T>+PartialEq{fn act_key(key:&Self::Key,act:&LazyMapAct<Self>)->Self::Key{FlattenAct::<Self::ActMonoid>::act(key,act)}}pub struct RangeSumRangeLinear<T>{_marker:PhantomData<fn()->T>}impl<T>LazyMapMonoid for RangeSumRangeLinear<T>where T:Copy+Zero+One+Add<Output=T>+Mul<Output=T>+PartialEq{type Key=T;type AggMonoid=(AdditiveOperation<T>,AdditiveOperation<T>);type ActMonoid=LinearOperation<T>;fn single_agg(key:&Self::Key)->LazyMapAgg<Self>{(*key,T::one())}fn act_agg(&(x,y):&LazyMapAgg<Self>,&(a,b):&LazyMapAct<Self>)->Option<LazyMapAgg<Self>>{Some((a*x+b*y,y))}}impl<T>LazyMapMonoidWithKeyAct for RangeSumRangeLinear<T>where T:Copy+Zero+One+Add<Output=T>+Mul<Output=T>+PartialEq{fn act_key(key:&Self::Key,act:&LazyMapAct<Self>)->Self::Key{LinearAct::act(key,act)}}pub struct RangePowerSumRangeLinear<T,const K:usize>{_marker:PhantomData<fn()->T>}impl<T,const K:usize>LazyMapMonoid for RangePowerSumRangeLinear<T,K>where T:Copy+Zero+One+Add<Output=T>+Mul<Output=T>+PartialEq{type Key=T;type AggMonoid=ArrayOperation<AdditiveOperation<T>,K>;type ActMonoid=LinearOperation<T>;fn single_agg(key:&Self::Key)->LazyMapAgg<Self>{let mut power=T::one();std::array::from_fn(|k|{if k!=0{power=power**key;}power})}fn act_agg(x:&LazyMapAgg<Self>,&(a,b):&LazyMapAct<Self>)->Option<LazyMapAgg<Self>>{let mut coefficients=[T::one();K];let mut result=*x;for k in 1..K{coefficients[k]=a*coefficients[k-1];for j in(1..k).rev(){coefficients[j]=b*coefficients[j]+a*coefficients[j-1];}coefficients[0]=b*coefficients[0];result[k]=coefficients[..=k].iter().zip(x).fold(T::zero(),|sum,(&c,&p)|sum+c*p);}Some(result)}}impl<T,const K:usize>LazyMapMonoidWithKeyAct for RangePowerSumRangeLinear<T,K>where T:Copy+Zero+One+Add<Output=T>+Mul<Output=T>+PartialEq{fn act_key(key:&Self::Key,act:&LazyMapAct<Self>)->Self::Key{LinearAct::act(key,act)}}pub struct RangeSumRangeUpdate<T>{_marker:PhantomData<fn()->T>}impl<T>LazyMapMonoid for RangeSumRangeUpdate<T>where T:Copy+Zero+One+Add<Output=T>+Mul<Output=T>+PartialEq{type Key=T;type AggMonoid=(AdditiveOperation<T>,AdditiveOperation<T>);type ActMonoid=LastOperation<T>;fn single_agg(key:&Self::Key)->LazyMapAgg<Self>{(*key,T::one())}fn act_agg(&(x,y):&LazyMapAgg<Self>,a:&LazyMapAct<Self>)->Option<LazyMapAgg<Self>>{Some((a.map(|a|a*y).unwrap_or(x),y))}}impl<T>LazyMapMonoidWithKeyAct for RangeSumRangeUpdate<T>where T:Copy+Zero+One+Add<Output=T>+Mul<Output=T>+PartialEq{fn act_key(key:&Self::Key,act:&LazyMapAct<Self>)->Self::Key{UpdateAct::act(key,act)}}pub struct RangeMaxRangeUpdate<T>{_marker:PhantomData<fn()->T>}impl<T>LazyMapMonoid for RangeMaxRangeUpdate<T>where T:Clone+PartialEq+Ord+Bounded{type Key=T;type AggMonoid=MaxOperation<T>;type ActMonoid=LastOperation<T>;fn single_agg(key:&Self::Key)->LazyMapAgg<Self>{key.clone()}fn act_agg(x:&LazyMapAgg<Self>,a:&LazyMapAct<Self>)->Option<LazyMapAgg<Self>>{Some(a.as_ref().unwrap_or(x).clone())}}impl<T>LazyMapMonoidWithKeyAct for RangeMaxRangeUpdate<T>where T:Clone+PartialEq+Ord+Bounded{fn act_key(key:&Self::Key,act:&LazyMapAct<Self>)->Self::Key{UpdateAct::act(key,act)}}pub struct RangeMinRangeUpdate<T>{_marker:PhantomData<fn()->T>}impl<T>LazyMapMonoid for RangeMinRangeUpdate<T>where T:Clone+PartialEq+Ord+Bounded{type Key=T;type AggMonoid=MinOperation<T>;type ActMonoid=LastOperation<T>;fn single_agg(key:&Self::Key)->LazyMapAgg<Self>{key.clone()}fn act_agg(x:&LazyMapAgg<Self>,a:&LazyMapAct<Self>)->Option<LazyMapAgg<Self>>{Some(a.as_ref().unwrap_or(x).clone())}}impl<T>LazyMapMonoidWithKeyAct for RangeMinRangeUpdate<T>where T:Clone+PartialEq+Ord+Bounded{fn act_key(key:&Self::Key,act:&LazyMapAct<Self>)->Self::Key{UpdateAct::act(key,act)}}pub struct RangeMaxRangeAdd<T>{_marker:PhantomData<fn()->T>}impl<T>LazyMapMonoid for RangeMaxRangeAdd<T>where T:Clone+Ord+Bounded+Zero+Add<Output=T>{type Key=T;type AggMonoid=MaxOperation<T>;type ActMonoid=AdditiveOperation<T>;fn single_agg(key:&Self::Key)->LazyMapAgg<Self>{key.clone()}fn act_agg(x:&LazyMapAgg<Self>,a:&LazyMapAct<Self>)->Option<LazyMapAgg<Self>>{Some(if Self::is_act_unit(a){x.clone()}else{x.clone()+a.clone()})}}impl<T>LazyMapMonoidWithKeyAct for RangeMaxRangeAdd<T>where T:Clone+Ord+Bounded+Zero+Add<Output=T>{fn act_key(key:&Self::Key,act:&LazyMapAct<Self>)->Self::Key{FlattenAct::<Self::ActMonoid>::act(key,act)}}pub struct RangeMinRangeAdd<T>{_marker:PhantomData<fn()->T>}impl<T>LazyMapMonoid for RangeMinRangeAdd<T>where T:Clone+Ord+Bounded+Zero+Add<Output=T>{type Key=T;type AggMonoid=MinOperation<T>;type ActMonoid=AdditiveOperation<T>;fn single_agg(key:&Self::Key)->LazyMapAgg<Self>{key.clone()}fn act_agg(x:&LazyMapAgg<Self>,a:&LazyMapAct<Self>)->Option<LazyMapAgg<Self>>{Some(if Self::is_act_unit(a){x.clone()}else{x.clone()+a.clone()})}}impl<T>LazyMapMonoidWithKeyAct for RangeMinRangeAdd<T>where T:Clone+Ord+Bounded+Zero+Add<Output=T>{fn act_key(key:&Self::Key,act:&LazyMapAct<Self>)->Self::Key{FlattenAct::<Self::ActMonoid>::act(key,act)}}pub struct RangeMinCountRangeAdd<T>{_marker:PhantomData<fn()->T>}impl<T>LazyMapMonoid for RangeMinCountRangeAdd<T>where T:Clone+Ord+Bounded+Zero+Add<Output=T>{type Key=T;type AggMonoid=CountingOperation<MinOperation<T>>;type ActMonoid=AdditiveOperation<T>;fn single_agg(key:&Self::Key)->LazyMapAgg<Self>{(key.clone(),1)}fn act_agg(x:&LazyMapAgg<Self>,a:&LazyMapAct<Self>)->Option<LazyMapAgg<Self>>{Some(if x.1==0{x.clone()}else{(x.0 .clone()+a.clone(),x.1)})}}impl<T>LazyMapMonoidWithKeyAct for RangeMinCountRangeAdd<T>where T:Clone+Ord+Bounded+Zero+Add<Output=T>{fn act_key(key:&Self::Key,act:&LazyMapAct<Self>)->Self::Key{FlattenAct::<Self::ActMonoid>::act(key,act)}}#[derive(Debug,Clone,Copy,PartialEq,Eq)]pub struct RangeChminChmaxAdd<T>{lb:T,ub:T,bias:T}impl<T>RangeChminChmaxAdd<T>where T:Zero+Bounded{pub fn chmin(x:T)->Self{Self{lb:T::minimum(),ub:x,bias:T::zero()}}pub fn chmax(x:T)->Self{Self{lb:x,ub:T::maximum(),bias:T::zero()}}pub fn add(x:T)->Self where T:Copy+Ord+Add<Output=T>{Self{lb:T::minimum()+x.max(T::zero()),ub:T::maximum()+x.min(T::zero()),bias:x}}}impl<T>Magma for RangeChminChmaxAdd<T>where T:Copy+Zero+Ord+Bounded+Add<Output=T>{type T=Self;fn operate(x:&Self::T,y:&Self::T)->Self::T{Self{lb:(x.lb+y.bias).max(y.lb).min(y.ub),ub:(x.ub+y.bias).max(y.lb).min(y.ub),bias:x.bias+y.bias}}}impl<T>Associative for RangeChminChmaxAdd<T>where T:Copy+Zero+Ord+Bounded+Add<Output=T>{}impl<T>Unital for RangeChminChmaxAdd<T>where T:Copy+Zero+Ord+Bounded+Add<Output=T>{fn unit()->Self::T{Self{lb:T::minimum(),ub:T::maximum(),bias:T::zero()}}}#[derive(Debug,Clone,PartialEq,Eq)]pub struct RangeSumRangeChminChmaxAdd<T>{min:T,max:T,min2:T,max2:T,pub sum:T,size:T,n_min:T,n_max:T}impl<T>RangeSumRangeChminChmaxAdd<T>where T:Copy+Zero+One+Ord+Bounded+Add<Output=T>+Sub<Output=T>+Mul<Output=T>+PartialEq{pub fn single(key:T,size:T)->Self{Self{min:key,max:key,min2:T::maximum(),max2:T::minimum(),sum:key*size,size,n_min:size,n_max:size}}}impl<T>Magma for RangeSumRangeChminChmaxAdd<T>where T:Copy+Zero+One+Ord+Bounded+Add<Output=T>+Sub<Output=T>+Mul<Output=T>+PartialEq{type T=Self;fn operate(x:&Self::T,y:&Self::T)->Self::T{Self{min:x.min.min(y.min),max:x.max.max(y.max),min2:if x.min==y.min{x.min2.min(y.min2)}else if x.min2<=y.min{x.min2}else if y.min2<=x.min{y.min2}else{x.min.max(y.min)},max2:if x.max==y.max{x.max2.max(y.max2)}else if x.max2>=y.max{x.max2}else if y.max2>=x.max{y.max2}else{x.max.min(y.max)},sum:x.sum+y.sum,size:x.size+y.size,n_min:match x.min.cmp(&y.min){Ordering::Less=>x.n_min,Ordering::Equal=>x.n_min+y.n_min,Ordering::Greater=>y.n_min,},n_max:match x.max.cmp(&y.max){Ordering::Less=>y.n_max,Ordering::Equal=>x.n_max+y.n_max,Ordering::Greater=>x.n_max,}}}}impl<T>Associative for RangeSumRangeChminChmaxAdd<T>where T:Copy+Zero+One+Ord+Bounded+Add<Output=T>+Sub<Output=T>+Mul<Output=T>+PartialEq{}impl<T>Unital for RangeSumRangeChminChmaxAdd<T>where T:Copy+Zero+One+Ord+Bounded+Add<Output=T>+Sub<Output=T>+Mul<Output=T>+PartialEq{fn unit()->Self::T{Self{min:T::maximum(),max:T::minimum(),min2:T::maximum(),max2:T::minimum(),sum:T::zero(),size:T::zero(),n_min:T::zero(),n_max:T::zero()}}}impl<T>MonoidAct for RangeChminChmaxAdd<T>where T:Copy+Zero+Ord+Bounded+Add<Output=T>{type Key=T;type Act=RangeChminChmaxAdd<T>;type ActMonoid=RangeChminChmaxAdd<T>;fn act(x:&Self::Key,a:&Self::Act)->Self::Key{(*x+a.bias).max(a.lb).min(a.ub)}}impl<T>LazyMapMonoid for RangeSumRangeChminChmaxAdd<T>where T:Copy+Zero+One+Ord+Bounded+Add<Output=T>+Sub<Output=T>+Mul<Output=T>+PartialEq{type Key=T;type AggMonoid=Self;type ActMonoid=RangeChminChmaxAdd<T>;fn single_agg(&key:&Self::Key)->LazyMapAgg<Self>{Self::single(key,T::one())}fn act_agg(x:&LazyMapAgg<Self>,a:&LazyMapAct<Self>)->Option<LazyMapAgg<Self>>{if Self::is_act_unit(a){return Some(x.clone());}if x.size.is_zero(){return Some(Self::unit());}let lb=a.lb-a.bias;let ub=a.ub-a.bias;let min=x.min.max(lb);let max=x.max.min(ub);Some(if min>=max{Self::single(RangeChminChmaxAdd::act(&x.min,a),x.size)}else if x.min2==x.max{let mut x=x.clone();let min=min+a.bias;let max=max+a.bias;x.min=min;x.max2=min;x.max=max;x.min2=max;x.sum=min*x.n_min+max*x.n_max;x}else if lb<x.min2&&x.max2<ub{let mut x=x.clone();x.sum=x.sum+(min-x.min)*x.n_min+(max-x.max)*x.n_max+a.bias*x.size;x.min=min+a.bias;x.max=max+a.bias;x.min2=x.min2+a.bias;x.max2=x.max2+a.bias;x}else{return None;})}}impl<T>LazyMapMonoidWithKeyAct for RangeSumRangeChminChmaxAdd<T>where T:Copy+Zero+One+Ord+Bounded+Add<Output=T>+Sub<Output=T>+Mul<Output=T>+PartialEq{fn act_key(key:&Self::Key,act:&LazyMapAct<Self>)->Self::Key{RangeChminChmaxAdd::act(key,act)}}}
// codesnip-guard: LinearOperation
#[cfg_attr(any(),rustfmt::skip)]pub use self::linear_operation_impl::LinearOperation;#[cfg_attr(any(),rustfmt::skip)]mod linear_operation_impl{use super::*;use std::{marker::PhantomData,ops::{Add,Div,Mul,Neg,Sub}};#[doc=" $(a, b) \\circ (c, d) = \\lambda x. c \\times (a \\times x + b) + d$"]pub struct LinearOperation<T>where T:Clone+Zero+Add<Output=T>+One+Mul<Output=T>{_marker:PhantomData<fn()->T>}impl<T>LinearOperation<T>where T:Clone+Zero+Add<Output=T>+One+Mul<Output=T>{pub fn apply(f:&(T,T),x:&T)->T{f.0 .clone()*x.clone()+f.1 .clone()}}impl<T>Magma for LinearOperation<T>where T:Clone+Zero+One+Add<Output=T>+Mul<Output=T>{type T=(T,T);#[inline]fn operate(x:&Self::T,y:&Self::T)->Self::T{(y.0 .clone()*x.0 .clone(),y.0 .clone()*x.1 .clone()+y.1 .clone())}}impl<T>Unital for LinearOperation<T>where T:Clone+Zero+One+Add<Output=T>+Mul<Output=T>{#[inline]fn unit()->Self::T{(One::one(),Zero::zero())}}impl<T>Associative for LinearOperation<T>where T:Clone+Zero+One+Add<Output=T>+Mul<Output=T>{}impl<T>Invertible for LinearOperation<T>where T:Clone+Zero+One+Add<Output=T>+Sub<Output=T>+Neg<Output=T>+Mul<Output=T>+Div<Output=T>{fn inverse(x:&Self::T)->Self::T{let y=<T as One>::one().div(x.0 .clone());(y.clone(),-y.mul(x.1 .clone()))}}}
// codesnip-guard: MaxOperation
#[cfg_attr(any(),rustfmt::skip)]pub use self::max_operation_impl::MaxOperation;#[cfg_attr(any(),rustfmt::skip)]mod max_operation_impl{use super::*;use std::marker::PhantomData;#[doc=" binary operation to select larger element"]pub struct MaxOperation<T>where T:Clone+Ord+Bounded{_marker:PhantomData<fn()->T>}impl<T>Magma for MaxOperation<T>where T:Clone+Ord+Bounded{type T=T;#[inline]fn operate(x:&Self::T,y:&Self::T)->Self::T{x.max(y).clone()}}impl<T>Unital for MaxOperation<T>where T:Clone+Ord+Bounded{#[inline]fn unit()->Self::T{<T as Bounded>::minimum()}}impl<T>Associative for MaxOperation<T>where T:Clone+Ord+Bounded{}impl<T>Commutative for MaxOperation<T>where T:Clone+Ord+Bounded{}impl<T>Idempotent for MaxOperation<T>where T:Clone+Ord+Bounded{}}
// codesnip-guard: MinOperation
#[cfg_attr(any(),rustfmt::skip)]pub use self::min_operation_impl::MinOperation;#[cfg_attr(any(),rustfmt::skip)]mod min_operation_impl{use super::*;use std::marker::PhantomData;#[doc=" binary operation to select smaller element"]pub struct MinOperation<T>where T:Clone+Ord+Bounded{_marker:PhantomData<fn()->T>}impl<T>Magma for MinOperation<T>where T:Clone+Ord+Bounded{type T=T;#[inline]fn operate(x:&Self::T,y:&Self::T)->Self::T{x.min(y).clone()}}impl<T>Unital for MinOperation<T>where T:Clone+Ord+Bounded{#[inline]fn unit()->Self::T{<T as Bounded>::maximum()}}impl<T>Associative for MinOperation<T>where T:Clone+Ord+Bounded{}impl<T>Commutative for MinOperation<T>where T:Clone+Ord+Bounded{}impl<T>Idempotent for MinOperation<T>where T:Clone+Ord+Bounded{}}
// codesnip-guard: MonoidAct
#[cfg_attr(any(),rustfmt::skip)]pub use self::action::*;#[cfg_attr(any(),rustfmt::skip)]mod action{use super::*;use std::{marker::PhantomData,ops::{Add,Mul}};pub trait MonoidAct{type Key;type Act:Clone;type ActMonoid:Monoid<T=Self::Act>;fn act(x:&Self::Key,a:&Self::Act)->Self::Key;fn act_assign(x:&mut Self::Key,a:&Self::Act){*x=Self::act(x,a);}fn unit()->Self::Act{<Self::ActMonoid as Unital>::unit()}fn operate(x:&Self::Act,y:&Self::Act)->Self::Act{<Self::ActMonoid as Magma>::operate(x,y)}fn operate_assign(x:&mut Self::Act,y:&Self::Act){*x=<Self::ActMonoid as Magma>::operate(x,y);}}pub struct EmptyAct<T>{_marker:PhantomData<fn()->T>}impl<T>MonoidAct for EmptyAct<T>where T:Clone{type Key=T;type Act=();type ActMonoid=();fn act(x:&Self::Key,_a:&Self::Act)->Self::Key{x.clone()}}pub struct FlattenAct<M>{_marker:PhantomData<fn()->M>}impl<M>MonoidAct for FlattenAct<M>where M:Monoid{type Key=M::T;type Act=M::T;type ActMonoid=M;fn act(x:&Self::Key,a:&Self::Act)->Self::Key{M::operate(x,a)}}pub struct LinearAct<T>{_marker:PhantomData<fn()->T>}impl<T>MonoidAct for LinearAct<T>where T:Clone+Zero+One+Add<Output=T>+Mul<Output=T>{type Key=T;type Act=(T,T);type ActMonoid=LinearOperation<T>;fn act(x:&Self::Key,(a,b):&Self::Act)->Self::Key{a.clone()*x.clone()+b.clone()}}pub struct UpdateAct<T>{_marker:PhantomData<fn()->T>}impl<T>MonoidAct for UpdateAct<T>where T:Clone{type Key=T;type Act=Option<T>;type ActMonoid=LastOperation<T>;fn act(x:&Self::Key,a:&Self::Act)->Self::Key{a.as_ref().unwrap_or(x).clone()}}}
// codesnip-guard: TupleOperation
#[cfg_attr(any(),rustfmt::skip)]mod tuple_operation_impl{use super::*;macro_rules!impl_tuple_operation{(@impl)=>{impl Magma for(){type T=();fn operate(_x:&Self::T,_y:&Self::T)->Self::T{}}impl Unital for(){fn unit()->Self::T{}}impl Associative for(){}impl Commutative for(){}impl Idempotent for(){}impl Invertible for(){fn inverse(_x:&Self::T)->Self::T{}}};(@impl$($T:ident$i:tt)*)=>{impl<$($T:Magma),*>Magma for($($T,)*){type T=($(<$T as Magma>::T,)*);fn operate(x:&Self::T,y:&Self::T)->Self::T{($(<$T as Magma>::operate(&x.$i,&y.$i),)*)}}impl<$($T:Unital),*>Unital for($($T,)*){fn unit()->Self::T{($(<$T as Unital>::unit(),)*)}}impl<$($T:Associative),*>Associative for($($T,)*){}impl<$($T:Commutative),*>Commutative for($($T,)*){}impl<$($T:Idempotent),*>Idempotent for($($T,)*){}impl<$($T:Invertible),*>Invertible for($($T,)*){fn inverse(x:&Self::T)->Self::T{($(<$T as Invertible>::inverse(&x.$i),)*)}}};(@inner$($T:ident$i:tt)*;$U:ident$j:tt$($t:tt)*)=>{impl_tuple_operation!(@impl$($T$i)*);impl_tuple_operation!(@inner$($T$i)*$U$j;$($t)*);};(@inner$($T:ident$i:tt)*;)=>{impl_tuple_operation!(@impl$($T$i)*);};($($t:tt)*)=>{impl_tuple_operation!(@inner;$($t)*);};}impl_tuple_operation!(A 0 B 1 C 2 D 3 E 4 F 5 G 6 H 7 I 8 J 9);}
// 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: discrete_steps
#[cfg_attr(any(),rustfmt::skip)]pub use self::discrete_steps::{DiscreteSteps,RangeBoundsExt};#[cfg_attr(any(),rustfmt::skip)]mod discrete_steps{use super::Bounded;use std::{convert::TryFrom,ops::{Bound,Range,RangeBounds,RangeInclusive}};pub trait DiscreteSteps<Delta>:Clone{fn delta()->Delta;fn steps_between(start:&Self,end:&Self)->Option<Delta>;fn forward_checked(start:Self,delta:Delta)->Option<Self>;fn backward_checked(start:Self,delta:Delta)->Option<Self>;fn forward(start:Self,delta:Delta)->Self{Self::forward_checked(start,delta).expect("overflow in `DiscreteSteps::forward`")}fn backward(start:Self,delta:Delta)->Self{Self::backward_checked(start,delta).expect("overflow in `DiscreteSteps::backward`")}fn forward_delta_checked(start:Self)->Option<Self>{Self::forward_checked(start,Self::delta())}fn backward_delta_checked(start:Self)->Option<Self>{Self::backward_checked(start,Self::delta())}fn forward_delta(start:Self)->Self{Self::forward(start,Self::delta())}fn backward_delta(start:Self)->Self{Self::backward(start,Self::delta())}}macro_rules!impl_discrete_steps_integer{(@common$u_source:ident)=>{fn delta()->$u_source{1}fn forward(start:Self,delta:$u_source)->Self{assert!(Self::forward_checked(start,delta).is_some(),"attempt to add with overflow");start.wrapping_add(delta as Self)}fn backward(start:Self,delta:$u_source)->Self{assert!(Self::backward_checked(start,delta).is_some(),"attempt to subtract with overflow");start.wrapping_sub(delta as Self)}};($u_source:ident$i_source:ident;$($u_narrower:ident$i_narrower:ident),*;$($u_wider:ident$i_wider:ident),*)=>{$(impl DiscreteSteps<$u_source>for$u_narrower{impl_discrete_steps_integer!(@common$u_source);fn steps_between(start:&Self,end:&Self)->Option<$u_source>{if*start<=*end{$u_source::try_from(*end-*start).ok()}else{None}}fn forward_checked(start:Self,delta:$u_source)->Option<Self>{Self::try_from(delta).ok().and_then(|delta|start.checked_add(delta))}fn backward_checked(start:Self,delta:$u_source)->Option<Self>{Self::try_from(delta).ok().and_then(|delta|start.checked_sub(delta))}}impl DiscreteSteps<$u_source>for$i_narrower{impl_discrete_steps_integer!(@common$u_source);fn steps_between(start:&Self,end:&Self)->Option<$u_source>{if*start<=*end{$u_source::try_from(end.abs_diff(*start)).ok()}else{None}}fn forward_checked(start:Self,delta:$u_source)->Option<Self>{$u_narrower::try_from(delta).ok().and_then(|delta|{let wrapped=start.wrapping_add(delta as Self);if wrapped>=start{Some(wrapped)}else{None}})}fn backward_checked(start:Self,delta:$u_source)->Option<Self>{$u_narrower::try_from(delta).ok().and_then(|delta|{let wrapped=start.wrapping_sub(delta as Self);if wrapped<=start{Some(wrapped)}else{None}})}})*$(impl DiscreteSteps<$u_source>for$u_wider{impl_discrete_steps_integer!(@common$u_source);fn steps_between(start:&Self,end:&Self)->Option<$u_source>{if*start<=*end{$u_source::try_from(*end-*start).ok()}else{None}}fn forward_checked(start:Self,delta:$u_source)->Option<Self>{start.checked_add(delta as Self)}fn backward_checked(start:Self,delta:$u_source)->Option<Self>{start.checked_sub(delta as Self)}}impl DiscreteSteps<$u_source>for$i_wider{impl_discrete_steps_integer!(@common$u_source);fn steps_between(start:&Self,end:&Self)->Option<$u_source>{if*start<=*end{end.checked_sub(*start).and_then(|result|$u_source::try_from(result).ok())}else{None}}fn forward_checked(start:Self,delta:$u_source)->Option<Self>{start.checked_add(delta as Self)}fn backward_checked(start:Self,delta:$u_source)->Option<Self>{start.checked_sub(delta as Self)}})*};}impl_discrete_steps_integer!(u16 i16;u8 i8,u16 i16,usize isize;u32 i32,u64 i64,u128 i128);impl_discrete_steps_integer!(u32 i32;u8 i8,u16 i16,u32 i32,usize isize;u64 i64,u128 i128);impl_discrete_steps_integer!(u64 i64;u8 i8,u16 i16,u32 i32,u64 i64,usize isize;u128 i128);impl_discrete_steps_integer!(u128 i128;u8 i8,u16 i16,u32 i32,u64 i64,u128 i128,usize isize;);impl_discrete_steps_integer!(usize isize;u8 i8,u16 i16,u32 i32,u64 i64,usize isize;u128 i128);pub trait RangeBoundsExt<T>{fn start_bound_included_checked(&self)->Option<T>;fn start_bound_excluded_checked(&self)->Option<T>;fn end_bound_included_checked(&self)->Option<T>;fn end_bound_excluded_checked(&self)->Option<T>;fn start_bound_included(&self)->T;fn start_bound_excluded(&self)->T;fn end_bound_included(&self)->T;fn end_bound_excluded(&self)->T;fn start_bound_included_bounded(&self,lb:T)->Option<T>where T:Ord;fn start_bound_excluded_bounded(&self,lb:T)->Option<T>where T:Ord;fn end_bound_included_bounded(&self,ub:T)->Option<T>where T:Ord;fn end_bound_excluded_bounded(&self,ub:T)->Option<T>where T:Ord;fn to_range_checked(&self)->Option<Range<T>>{match(self.start_bound_included_checked(),self.end_bound_excluded_checked()){(Some(start),Some(end))=>Some(start..end),_=>None,}}fn to_range(&self)->Range<T>{self.start_bound_included()..self.end_bound_excluded()}fn to_range_bounded(&self,min:T,max:T)->Option<Range<T>>where T:Ord{Some(self.start_bound_included_bounded(min)?..self.end_bound_excluded_bounded(max)?)}fn to_range_inclusive_checked(&self)->Option<RangeInclusive<T>>{match(self.start_bound_included_checked(),self.end_bound_included_checked()){(Some(start),Some(end))=>Some(start..=end),_=>None,}}fn to_range_inclusive(&self)->RangeInclusive<T>{self.start_bound_included()..=self.end_bound_included()}fn to_range_inclusive_bounded(&self,min:T,max:T)->Option<RangeInclusive<T>>where T:Ord{Some(self.start_bound_included_bounded(min)?..=self.end_bound_included_bounded(max)?)}}macro_rules!impl_range_bounds_ext{($($source:ident=>$($target:ident)+);*$(;)?)=>{$($(impl<R>RangeBoundsExt<$target>for R where R:RangeBounds<$target>,{fn start_bound_included_checked(&self)->Option<$target>{match self.start_bound(){Bound::Included(x)=>Some(*x),Bound::Excluded(x)=>DiscreteSteps::<$source>::forward_delta_checked(*x),Bound::Unbounded=>Some(Bounded::minimum()),}}fn start_bound_excluded_checked(&self)->Option<$target>{match self.start_bound(){Bound::Included(x)=>DiscreteSteps::<$source>::backward_delta_checked(*x),Bound::Excluded(x)=>Some(*x),Bound::Unbounded=>None,}}fn end_bound_included_checked(&self)->Option<$target>{match self.end_bound(){Bound::Included(x)=>Some(*x),Bound::Excluded(x)=>DiscreteSteps::<$source>::backward_delta_checked(*x),Bound::Unbounded=>Some(Bounded::maximum()),}}fn end_bound_excluded_checked(&self)->Option<$target>{match self.end_bound(){Bound::Included(x)=>DiscreteSteps::<$source>::forward_delta_checked(*x),Bound::Excluded(x)=>Some(*x),Bound::Unbounded=>None,}}fn start_bound_included(&self)->$target{match self.start_bound(){Bound::Included(x)=>*x,Bound::Excluded(x)=>DiscreteSteps::<$source>::forward_delta(*x),Bound::Unbounded=>Bounded::minimum(),}}fn start_bound_excluded(&self)->$target{match self.start_bound(){Bound::Included(x)=>DiscreteSteps::<$source>::backward_delta(*x),Bound::Excluded(x)=>*x,Bound::Unbounded=>DiscreteSteps::<$source>::backward_delta(Bounded::minimum()),}}fn end_bound_included(&self)->$target{match self.end_bound(){Bound::Included(x)=>*x,Bound::Excluded(x)=>DiscreteSteps::<$source>::backward_delta(*x),Bound::Unbounded=>Bounded::maximum(),}}fn end_bound_excluded(&self)->$target{match self.end_bound(){Bound::Included(x)=>DiscreteSteps::<$source>::forward_delta(*x),Bound::Excluded(x)=>*x,Bound::Unbounded=>DiscreteSteps::<$source>::forward_delta(Bounded::maximum()),}}fn start_bound_included_bounded(&self,lb:$target)->Option<$target>where$target:Ord{match self.start_bound(){Bound::Included(x)=>Some(*x).filter(|&x|lb<=x),Bound::Excluded(x)=>DiscreteSteps::<$source>::forward_delta_checked(*x).filter(|&x|lb<=x),Bound::Unbounded=>Some(lb),}}fn start_bound_excluded_bounded(&self,lb:$target)->Option<$target>where$target:Ord{match self.start_bound(){Bound::Included(x)=>DiscreteSteps::<$source>::backward_delta_checked(*x).filter(|&x|lb<=x),Bound::Excluded(x)=>Some(*x).filter(|&x|lb<=x),Bound::Unbounded=>Some(lb),}}fn end_bound_included_bounded(&self,ub:$target)->Option<$target>where$target:Ord{match self.end_bound(){Bound::Included(x)=>Some(*x).filter(|&x|x<=ub),Bound::Excluded(x)=>DiscreteSteps::<$source>::backward_delta_checked(*x).filter(|&x|x<=ub),Bound::Unbounded=>Some(ub),}}fn end_bound_excluded_bounded(&self,ub:$target)->Option<$target>where$target:Ord{match self.end_bound(){Bound::Included(x)=>DiscreteSteps::<$source>::forward_delta_checked(*x).filter(|&x|x<=ub),Bound::Excluded(x)=>Some(*x).filter(|&x|x<=ub),Bound::Unbounded=>Some(ub),}}})+)*};}impl_range_bounds_ext!(u16=>u8 i8 u16 i16;u32=>u32 i32;u64=>u64 i64;u128=>u128 i128;usize=>isize usize;);}
// 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())});}