// codesnip-guard: PersistentSegmentTree
#[cfg_attr(any(),rustfmt::skip)]pub use self::persistent_segment_tree::PersistentSegmentTree;#[cfg_attr(any(),rustfmt::skip)]mod persistent_segment_tree{use super::{Allocator,MemoryPool,Monoid,RangeBoundsExt};use std::{fmt::{self,Debug,Formatter},ops::{Range,RangeBounds},ptr::NonNull};type NodePtr<T>=Option<NonNull<Node<T>>>;struct Node<T>{children:[NodePtr<T>;2],value:T}impl<T>Node<T>{fn new(children:[NodePtr<T>;2],value:T)->Self{Self{children,value}}}#[derive(Debug,Clone,Copy,PartialEq,Eq,Hash)]#[must_use]pub struct PersistentSegmentTreeVersion(usize);impl PersistentSegmentTreeVersion{fn base()->Self{Self(0)}fn new(version_id:usize)->Self{Self(version_id)}fn index(self)->usize{self.0}}pub struct PersistentSegmentTree<M>where M:Monoid{len:usize,version_roots:Vec<NodePtr<M::T>>,allocator:MemoryPool<Node<M::T>>}impl<M>Debug for PersistentSegmentTree<M>where M:Monoid{fn fmt(&self,f:&mut Formatter<'_>)->fmt::Result{f.debug_struct("PersistentSegmentTree").field("len",&self.len).field("versions",&self.version_roots.len()).finish()}}impl<M>PersistentSegmentTree<M>where M:Monoid{#[must_use]pub fn new(len:usize)->Self{Self{len,version_roots:vec![None],allocator:MemoryPool::new()}}pub fn base(&self)->PersistentSegmentTreeVersion{PersistentSegmentTreeVersion::base()}pub fn len(&self)->usize{self.len}pub fn is_empty(&self)->bool{self.len==0}fn version_root(&self,version:PersistentSegmentTreeVersion)->NodePtr<M::T>{*self.version_roots.get(version.index()).expect("invalid version")}fn push_version_root(&mut self,root:NodePtr<M::T>)->PersistentSegmentTreeVersion{let version_id=self.version_roots.len();self.version_roots.push(root);PersistentSegmentTreeVersion::new(version_id)}fn allocate_node(&mut self,children:[NodePtr<M::T>;2],value:M::T)->NonNull<Node<M::T>>{self.allocator.allocate(Node::new(children,value))}fn build_dfs(&mut self,start:usize,end:usize,values:&[M::T])->NodePtr<M::T>{if end-start==1{return self.leaf_node(values[start].clone());}let mid=(start+end)/2;let left=self.build_dfs(start,mid,values);let right=self.build_dfs(mid,end,values);self.merge_nodes(left,right)}fn leaf_node(&mut self,value:M::T)->NodePtr<M::T>{Some(self.allocate_node([None,None],value))}fn merge_nodes(&mut self,left:NodePtr<M::T>,right:NodePtr<M::T>)->NodePtr<M::T>{if left.is_none()&&right.is_none(){None}else{let value=M::operate(&Self::subtree_value(left),&Self::subtree_value(right));Some(self.allocate_node([left,right],value))}}fn subtree_value(node:NodePtr<M::T>)->M::T{node.map(|node|unsafe{node.as_ref().value.clone()}).unwrap_or_else(M::unit)}fn children(node:NodePtr<M::T>)->[NodePtr<M::T>;2]{node.map(|node|unsafe{node.as_ref().children}).unwrap_or([None,None])}fn point_get_dfs(node:NodePtr<M::T>,start:usize,end:usize,index:usize)->M::T{let Some(node)=node else{return M::unit();};let node=unsafe{node.as_ref()};if end-start==1{node.value.clone()}else{let mid=(start+end)/2;if index<mid{Self::point_get_dfs(node.children[0],start,mid,index)}else{Self::point_get_dfs(node.children[1],mid,end,index)}}}fn fold_dfs(node:NodePtr<M::T>,start:usize,end:usize,range:&Range<usize>)->M::T{if range.end<=start||end<=range.start{return M::unit();}let Some(node)=node else{return M::unit();};let node=unsafe{node.as_ref()};if range.start<=start&&end<=range.end{node.value.clone()}else{let mid=(start+end)/2;if range.end<=mid{return Self::fold_dfs(node.children[0],start,mid,range);}if mid<=range.start{return Self::fold_dfs(node.children[1],mid,end,range);}let left=Self::fold_dfs(node.children[0],start,mid,range);let right=Self::fold_dfs(node.children[1],mid,end,range);M::operate(&left,&right)}}fn partition_point_dfs<P>(node:NodePtr<M::T>,start:usize,end:usize,left:usize,acc:&mut M::T,pred:&mut P)->Option<usize>where P:FnMut(&M::T)->bool{if end<=left{return None;}if left<=start{let nacc=M::operate(acc,&Self::subtree_value(node));if pred(&nacc){*acc=nacc;return None;}if end-start==1{return Some(start);}}let mid=(start+end)/2;let[l,r]=Self::children(node);if let Some(pos)=Self::partition_point_dfs(l,start,mid,left,acc,pred){Some(pos)}else{Self::partition_point_dfs(r,mid,end,left,acc,pred)}}fn rpartition_point_dfs<P>(node:NodePtr<M::T>,start:usize,end:usize,right:usize,acc:&mut M::T,pred:&mut P)->Option<usize>where P:FnMut(&M::T)->bool{if right<=start{return None;}if end<=right{let nacc=M::operate(&Self::subtree_value(node),acc);if pred(&nacc){*acc=nacc;return None;}if end-start==1{return Some(end);}}let mid=(start+end)/2;let[l,r]=Self::children(node);if let Some(pos)=Self::rpartition_point_dfs(r,mid,end,right,acc,pred){Some(pos)}else{Self::rpartition_point_dfs(l,start,mid,right,acc,pred)}}fn set_dfs(&mut self,node:NodePtr<M::T>,start:usize,end:usize,index:usize,value:&M::T)->NodePtr<M::T>{if end-start==1{return self.leaf_node(value.clone());}let mid=(start+end)/2;let mut children=Self::children(node);if index<mid{children[0]=self.set_dfs(children[0],start,mid,index,value);}else{children[1]=self.set_dfs(children[1],mid,end,index,value);}self.merge_nodes(children[0],children[1])}fn update_dfs(&mut self,node:NodePtr<M::T>,start:usize,end:usize,index:usize,value:&M::T)->NodePtr<M::T>{if end-start==1{return self.leaf_node(M::operate(&Self::subtree_value(node),value));}let mid=(start+end)/2;let mut children=Self::children(node);if index<mid{children[0]=self.update_dfs(children[0],start,mid,index,value);}else{children[1]=self.update_dfs(children[1],mid,end,index,value);}self.merge_nodes(children[0],children[1])}pub fn from_vec(&mut self,v:Vec<M::T>)->PersistentSegmentTreeVersion{assert_eq!(v.len(),self.len);let root=if self.len==0{None}else{self.build_dfs(0,self.len,&v)};self.push_version_root(root)}pub fn set(&mut self,version:PersistentSegmentTreeVersion,index:usize,value:M::T)->PersistentSegmentTreeVersion{assert!(index<self.len);let root=self.set_dfs(self.version_root(version),0,self.len,index,&value);self.push_version_root(root)}pub fn update(&mut self,version:PersistentSegmentTreeVersion,index:usize,value:M::T)->PersistentSegmentTreeVersion{assert!(index<self.len);let root=self.update_dfs(self.version_root(version),0,self.len,index,&value);self.push_version_root(root)}#[must_use]pub fn get(&self,version:PersistentSegmentTreeVersion,index:usize)->M::T{assert!(index<self.len);Self::point_get_dfs(self.version_root(version),0,self.len,index)}#[must_use]pub fn fold<R>(&self,version:PersistentSegmentTreeVersion,range:R)->M::T where R:RangeBounds<usize>{let range=range.to_range_bounded(0,self.len).expect("invalid range");if range.is_empty(){M::unit()}else{Self::fold_dfs(self.version_root(version),0,self.len,&range)}}pub fn partition_point_acc<P>(&self,version:PersistentSegmentTreeVersion,left:usize,mut pred:P)->(usize,M::T)where P:FnMut(&M::T)->bool{let root=self.version_root(version);let mut acc=M::unit();let pos=if self.len==0{None}else{Self::partition_point_dfs(root,0,self.len,left,&mut acc,&mut pred)};(pos.unwrap_or(self.len),acc)}pub fn rpartition_point_acc<P>(&self,version:PersistentSegmentTreeVersion,right:usize,mut pred:P)->(usize,M::T)where P:FnMut(&M::T)->bool{let root=self.version_root(version);let mut acc=M::unit();let pos=if self.len==0{None}else{Self::rpartition_point_dfs(root,0,self.len,right,&mut acc,&mut pred)};(pos.unwrap_or(0),acc)}#[must_use]pub fn fold_all(&self,version:PersistentSegmentTreeVersion)->M::T{Self::subtree_value(self.version_root(version))}}}
// codesnip-guard: Allocator
#[cfg_attr(any(),rustfmt::skip)]pub use self::allocator::{Allocator,BoxAllocator,MemoryPool};#[cfg_attr(any(),rustfmt::skip)]mod allocator{use std::{fmt::{self,Debug},marker::PhantomData,mem::{replace,size_of,take},ptr::{self,NonNull,read,write}};#[doc=" # Safety"]#[doc=" Allocations must contain the supplied value and remain valid until deallocation"]#[doc=" or allocator destruction. Live nonzero-sized allocations must not overlap."]pub unsafe trait Allocator<T>{fn allocate(&mut self,value:T)->NonNull<T>;#[doc=" # Safety"]#[doc=" `ptr` must hold a live value allocated by this allocator, with no remaining"]#[doc=" references. The allocation must not be accessed after this call."]unsafe fn deallocate(&mut self,ptr:NonNull<T>)->T;}pub struct MemoryPool<T>{pool:Vec<T>,chunks:Vec<Vec<T>>,unused:Vec<NonNull<T>>}impl<T>Debug for MemoryPool<T>{fn fmt(&self,f:&mut fmt::Formatter<'_>)->fmt::Result{f.debug_struct("MemoryPool").field("pool_len",&self.pool.len()).field("chunks",&self.chunks.len()).field("unused",&self.unused.len()).finish()}}impl<T>Default for MemoryPool<T>{fn default()->Self{Self::with_capacity(CAP/1usize.max(size_of::<T>()))}}const CAP:usize=1024;impl<T>MemoryPool<T>{pub fn new()->Self{Default::default()}pub fn with_capacity(capacity:usize)->Self{let pool=Vec::with_capacity(capacity.max(1));Self{pool,chunks:Vec::new(),unused:Vec::new()}}}impl<T>Drop for MemoryPool<T>{fn drop(&mut self){if size_of::<T>()==0{let mut unused=self.unused.len();for chunk in std::iter::once(&mut self.pool).chain(&mut self.chunks){let removed=unused.min(chunk.len());unsafe{chunk.set_len(chunk.len()-removed)};unused-=removed;}return;}self.chunks.push(take(&mut self.pool));let mut removed=vec![vec![];self.chunks.len()];for p in self.unused.iter(){let p=p.as_ptr();for(chunk,removed)in self.chunks.iter().zip(&mut removed).rev(){let ptr=chunk.as_ptr()as*mut _;let len=chunk.len();if ptr<=p&&p<ptr.wrapping_add(len){removed.push(p);}}}for(chunk,removed)in self.chunks.iter_mut().zip(&mut removed){removed.sort_unstable();for&p in removed.iter().rev(){unsafe{let len=chunk.len();let base_ptr=chunk.as_mut_ptr();ptr::copy(base_ptr.add(len-1),p,1);chunk.set_len(len-1);}}}}}unsafe impl<T>Allocator<T>for MemoryPool<T>{fn allocate(&mut self,value:T)->NonNull<T>{if let Some(ptr)=self.unused.pop(){unsafe{write(ptr.as_ptr(),value)};ptr}else{let len=self.pool.len();if len>=self.pool.capacity(){let new_capacity=self.pool.capacity()*2;let new_pool=Vec::with_capacity(new_capacity);self.chunks.push(replace(&mut self.pool,new_pool));}let len=self.pool.len();debug_assert!(len<self.pool.capacity());self.pool.push(value);unsafe{NonNull::new_unchecked(self.pool.as_mut_ptr().add(len))}}}unsafe fn deallocate(&mut self,ptr:NonNull<T>)->T{self.unused.push(ptr);unsafe{read(ptr.as_ptr())}}}#[derive(Debug)]pub struct BoxAllocator<T>(PhantomData<fn()->T>);impl<T>Default for BoxAllocator<T>{fn default()->Self{Self(PhantomData)}}unsafe impl<T>Allocator<T>for BoxAllocator<T>{fn allocate(&mut self,value:T)->NonNull<T>{unsafe{NonNull::new_unchecked(Box::leak(Box::new(value)))}}unsafe fn deallocate(&mut self,ptr:NonNull<T>)->T{unsafe{*Box::from_raw(ptr.as_ptr())}}}}
// 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: 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;);}