// codesnip-guard: tree_generator
#[cfg_attr(any(),rustfmt::skip)]pub use self::generator::*;#[cfg_attr(any(),rustfmt::skip)]mod generator{use super::{RandomSpec,UndirectedSparseGraph,Xorshift};#[doc=" Generate Tree with Prüfer sequence"]pub struct PruferSequence<T>(pub T);impl<T:RandomSpec<usize>>RandomSpec<UndirectedSparseGraph>for PruferSequence<T>{fn rand(&self,rng:&mut Xorshift)->UndirectedSparseGraph{let n=rng.random(&self.0);let edges=from_prufer_sequence(n,&rng.random_iter(0..n).take(n.saturating_sub(2)).collect::<Vec<usize>>());UndirectedSparseGraph::from_edges(n,edges)}}pub struct PathTree<T>(pub T);impl<T:RandomSpec<usize>>RandomSpec<UndirectedSparseGraph>for PathTree<T>{fn rand(&self,rng:&mut Xorshift)->UndirectedSparseGraph{let n=rng.random(&self.0);let edges=(1..n).map(|u|(u-1,u)).collect();UndirectedSparseGraph::from_edges(n,edges)}}pub struct StarTree<T>(pub T);impl<T:RandomSpec<usize>>RandomSpec<UndirectedSparseGraph>for StarTree<T>{fn rand(&self,rng:&mut Xorshift)->UndirectedSparseGraph{let n=rng.random(&self.0);let edges=(1..n).map(|u|(0,u)).collect();UndirectedSparseGraph::from_edges(n,edges)}}pub struct MixedTree<T>(pub T);impl<T:RandomSpec<usize>>RandomSpec<UndirectedSparseGraph>for MixedTree<T>{fn rand(&self,rng:&mut Xorshift)->UndirectedSparseGraph{fn rand_inner(n:usize,rng:&mut Xorshift)->Vec<(usize,usize)>{let mut edges=Vec::with_capacity(n.saturating_sub(1));if n>=2{let k=rng.random(1..n);for n in[k,n-k].iter().cloned(){let ty=rng.rand(6);edges.extend(match ty{0=>from_prufer_sequence(n,&rng.random_iter(0..n).take(n.saturating_sub(2)).collect::<Vec<usize>>()),1=>(1..n).map(|u|(u-1,u)).collect(),2=>(1..n).map(|u|(0,u)).collect(),_=>rand_inner(n,rng),});}for(u,v)in edges[k-1..].iter_mut(){*u+=k;*v+=k;}edges.push((rng.random(0..k),rng.random(k..n)));}edges}let n=rng.random(&self.0);let edges=rand_inner(n,rng);UndirectedSparseGraph::from_edges(n,edges)}}fn from_prufer_sequence(n:usize,prufer:&[usize])->Vec<(usize,usize)>{use std::collections::BinaryHeap;let mut edges=Vec::with_capacity(n.saturating_sub(1));if n>=2{let mut deg=vec![0usize;n];prufer.iter().for_each(|&a|deg[a]+=1);let mut heap:BinaryHeap<usize>=(0..n).filter(|&u|deg[u]==0).collect();for&a in prufer{deg[a]-=1;let b=heap.pop().unwrap();edges.push((a,b));if deg[a]==0{heap.push(a);}}edges.push((heap.pop().unwrap(),heap.pop().unwrap()));}edges}}
// codesnip-guard: Graph
#[cfg_attr(any(),rustfmt::skip)]pub use self::graph_base::*;#[cfg_attr(any(),rustfmt::skip)]mod graph_base{#[doc=" A neighboring vertex and the label of the arc used to reach it."]#[derive(Debug,Clone,Copy,PartialEq,Eq,PartialOrd,Ord,Hash)]pub struct Neighbor<V,L>{pub to:V,pub label:L}impl<V,L>Neighbor<V,L>{#[inline]pub fn new(to:V,label:L)->Self{Self{to,label}}}impl<V,L>From<(V,L)>for Neighbor<V,L>{#[inline]fn from((to,label):(V,L))->Self{Self::new(to,label)}}#[doc=" A finite graph whose outgoing arcs can be iterated without allocation."]pub trait Graph{type Vertex:Copy+Eq;type Label;type Vertices<'g>:Iterator<Item=Self::Vertex>where Self:'g;type Neighbors<'g>:Iterator<Item=Neighbor<Self::Vertex,Self::Label>>where Self:'g;fn vsize(&self)->usize;fn vertices(&self)->Self::Vertices<'_>;fn neighbors(&self,vertex:Self::Vertex)->Self::Neighbors<'_>;}#[doc=" A graph whose adjacency relation represents directed arcs."]pub trait DirectedGraph:Graph{}pub trait VertexMap<T>:Graph{type Vmap;fn construct_vmap<F>(&self,f:F)->Self::Vmap where F:FnMut()->T;fn vmap_get<'a>(&self,map:&'a Self::Vmap,vertex:Self::Vertex)->&'a T;fn vmap_get_mut<'a>(&self,map:&'a mut Self::Vmap,vertex:Self::Vertex)->&'a mut T;#[inline]fn vmap_set(&self,map:&mut Self::Vmap,vertex:Self::Vertex,value:T){*self.vmap_get_mut(map,vertex)=value;}}pub trait EdgeMap<T>:Graph{type Emap;fn construct_emap<F>(&self,f:F)->Self::Emap where F:FnMut()->T;fn emap_get<'a>(&self,map:&'a Self::Emap,eid:Self::Label)->&'a T;fn emap_get_mut<'a>(&self,map:&'a mut Self::Emap,eid:Self::Label)->&'a mut T;#[inline]fn emap_set(&self,map:&mut Self::Emap,eid:Self::Label,value:T){*self.emap_get_mut(map,eid)=value;}}}
// codesnip-guard: SparseGraph
#[cfg_attr(any(),rustfmt::skip)]pub use self::sparse_graph::*;#[cfg_attr(any(),rustfmt::skip)]mod sparse_graph{use super::{DirectedGraph,EdgeMap,Graph,MarkedScan,Neighbor,Scan,ScanSource,VertexMap};use std::{iter::Copied,marker::PhantomData,ops,slice};type Marker<T>=PhantomData<fn()->T>;#[derive(Clone,Copy,Debug,Eq,PartialEq,Ord,PartialOrd,Hash)]pub enum DirectedEdge{}#[derive(Clone,Copy,Debug,Eq,PartialEq,Ord,PartialOrd,Hash)]pub enum UndirectedEdge{}#[derive(Clone,Copy,Debug,Eq,PartialEq,Ord,PartialOrd,Hash)]pub enum BidirectionalEdge{}#[doc=" Static Sparse Graph represented as Compressed Sparse Row."]#[derive(Debug,Clone)]pub struct SparseGraph<D>{vsize:usize,start:Vec<usize>,neighbors:Vec<Neighbor<usize,usize>>,pub edges:Vec<(usize,usize)>,_marker:Marker<D>}impl<D>SparseGraph<D>{#[doc=" Return the number of vertices."]#[inline]pub fn vertices_size(&self)->usize{self.vsize}#[doc=" Return the number of edges."]#[inline]pub fn edges_size(&self)->usize{self.edges.len()}#[doc=" Return an iterator over graph vertices."]#[inline]pub fn vertices(&self)->ops::Range<usize>{0..self.vertices_size()}pub fn builder<T>(vsize:usize)->SparseGraphBuilder<T,D>{SparseGraphBuilder::new(vsize)}pub fn builder_with_esize<T>(vsize:usize,esize:usize)->SparseGraphBuilder<T,D>{SparseGraphBuilder::new_with_esize(vsize,esize)}}pub trait SparseGraphConstruction:Sized{fn construct_graph(vsize:usize,edges:Vec<(usize,usize)>)->SparseGraph<Self>;}impl<D>SparseGraph<D>where D:SparseGraphConstruction{#[doc=" Construct graph from edges."]pub fn from_edges(vsize:usize,edges:Vec<(usize,usize)>)->Self{D::construct_graph(vsize,edges)}pub fn reverse_graph(&self)->SparseGraph<D>{let edges=self.edges.iter().map(|&(from,to)|(to,from)).collect();D::construct_graph(self.vsize,edges)}}impl SparseGraphConstruction for DirectedEdge{fn construct_graph(vsize:usize,edges:Vec<(usize,usize)>)->SparseGraph<Self>{let mut start:Vec<_>=vec![0usize;vsize+1];for(from,_)in edges.iter().cloned(){start[from]+=1;}for i in 1..=vsize{start[i]+=start[i-1];}let mut neighbors=Vec::<Neighbor<usize,usize>>::with_capacity(edges.len());let ptr=neighbors.as_mut_ptr();for(id,(from,to))in edges.iter().cloned().enumerate(){start[from]-=1;unsafe{ptr.add(start[from]).write(Neighbor::new(to,id))};}unsafe{neighbors.set_len(edges.len())};SparseGraph{vsize,start,neighbors,edges,_marker:PhantomData}}}impl SparseGraphConstruction for UndirectedEdge{fn construct_graph(vsize:usize,edges:Vec<(usize,usize)>)->SparseGraph<Self>{let mut start:Vec<_>=vec![0usize;vsize+1];for(from,to)in edges.iter().cloned(){start[to]+=1;start[from]+=1;}for i in 1..=vsize{start[i]+=start[i-1];}let mut neighbors=Vec::<Neighbor<usize,usize>>::with_capacity(edges.len()*2);let ptr=neighbors.as_mut_ptr();for(id,(from,to))in edges.iter().cloned().enumerate(){start[from]-=1;unsafe{ptr.add(start[from]).write(Neighbor::new(to,id))};start[to]-=1;unsafe{ptr.add(start[to]).write(Neighbor::new(from,id))};}unsafe{neighbors.set_len(edges.len()*2)};SparseGraph{vsize,start,neighbors,edges,_marker:PhantomData}}}impl SparseGraphConstruction for BidirectionalEdge{fn construct_graph(vsize:usize,edges:Vec<(usize,usize)>)->SparseGraph<Self>{let mut start:Vec<_>=vec![0usize;vsize+1];for(from,to)in edges.iter().cloned(){start[to]+=1;start[from]+=1;}for i in 1..=vsize{start[i]+=start[i-1];}let mut neighbors=Vec::<Neighbor<usize,usize>>::with_capacity(edges.len()*2);let ptr=neighbors.as_mut_ptr();for(id,(from,to))in edges.iter().cloned().enumerate(){start[from]-=1;unsafe{ptr.add(start[from]).write(Neighbor::new(to,id*2))};start[to]-=1;unsafe{ptr.add(start[to]).write(Neighbor::new(from,id*2+1))};}unsafe{neighbors.set_len(edges.len()*2)};SparseGraph{vsize,start,neighbors,edges,_marker:PhantomData}}}pub type DirectedSparseGraph=SparseGraph<DirectedEdge>;pub type UndirectedSparseGraph=SparseGraph<UndirectedEdge>;pub type BidirectionalSparseGraph=SparseGraph<BidirectionalEdge>;pub struct SparseGraphBuilder<T,D>{vsize:usize,edges:Vec<(usize,usize)>,rest:Vec<T>,_marker:Marker<D>}impl<T,D>SparseGraphBuilder<T,D>{pub fn new(vsize:usize)->Self{Self{vsize,edges:Default::default(),rest:Default::default(),_marker:PhantomData}}pub fn new_with_esize(vsize:usize,esize:usize)->Self{Self{vsize,edges:Vec::with_capacity(esize),rest:Vec::with_capacity(esize),_marker:PhantomData}}pub fn add_edge(&mut self,u:usize,v:usize,w:T){self.edges.push((u,v));self.rest.push(w);}}impl<T,D>SparseGraphBuilder<T,D>where D:SparseGraphConstruction{pub fn build(self)->(SparseGraph<D>,Vec<T>){let graph=SparseGraph::from_edges(self.vsize,self.edges);(graph,self.rest)}}pub struct SparseGraphScanner<U,T,D>where U:Scan<Output=usize>,T:Scan{vsize:usize,esize:usize,_marker:Marker<(U,T,D)>}impl<U,T,D>SparseGraphScanner<U,T,D>where U:Scan<Output=usize>,T:Scan{pub fn new(vsize:usize,esize:usize)->Self{Self{vsize,esize,_marker:PhantomData}}}impl<U,T,D>MarkedScan for SparseGraphScanner<U,T,D>where U:Scan<Output=usize>,T:Scan,D:SparseGraphConstruction{type Output=(SparseGraph<D>,Vec<<T as Scan>::Output>);fn mscan<I:ScanSource>(self,iter:&mut I)->Option<Self::Output>{let mut builder=SparseGraphBuilder::new_with_esize(self.vsize,self.esize);for _ in 0..self.esize{builder.add_edge(U::scan(iter)?,U::scan(iter)?,T::scan(iter)?);}Some(builder.build())}}pub type DirectedGraphScanner<U,T=()>=SparseGraphScanner<U,T,DirectedEdge>;pub type UndirectedGraphScanner<U,T=()>=SparseGraphScanner<U,T,UndirectedEdge>;pub type BidirectionalGraphScanner<U,T=()>=SparseGraphScanner<U,T,BidirectionalEdge>;pub struct TreeGraphScanner<U,T=()>where U:Scan<Output=usize>,T:Scan{vsize:usize,_marker:Marker<(U,T)>}impl<U,T>TreeGraphScanner<U,T>where U:Scan<Output=usize>,T:Scan{pub fn new(vsize:usize)->Self{Self{vsize,_marker:PhantomData}}}impl<U,T>MarkedScan for TreeGraphScanner<U,T>where U:Scan<Output=usize>,T:Scan{type Output=(UndirectedSparseGraph,Vec<<T as Scan>::Output>);fn mscan<I:ScanSource>(self,iter:&mut I)->Option<Self::Output>{UndirectedGraphScanner::<U,T>::new(self.vsize,self.vsize-1).mscan(iter)}}impl<D>Graph for SparseGraph<D>where D:SparseGraphConstruction{type Vertex=usize;type Label=usize;type Vertices<'g>=ops::Range<usize>where D:'g;type Neighbors<'g>=Copied<slice::Iter<'g,Neighbor<usize,usize>>>where D:'g;#[inline]fn vsize(&self)->usize{self.vsize}#[inline]fn vertices(&self)->Self::Vertices<'_>{0..self.vsize}#[inline]fn neighbors(&self,vertex:Self::Vertex)->Self::Neighbors<'_>{self.neighbors[self.start[vertex]..self.start[vertex+1]].iter().copied()}}impl DirectedGraph for SparseGraph<DirectedEdge>{}impl<T>EdgeMap<T>for SparseGraph<DirectedEdge>{type Emap=Vec<T>;#[inline]fn construct_emap<F>(&self,f:F)->Self::Emap where F:FnMut()->T{let mut map=Vec::with_capacity(self.edges.len());map.resize_with(self.edges.len(),f);map}#[inline]fn emap_get<'a>(&self,map:&'a Self::Emap,eid:Self::Label)->&'a T{&map[eid]}#[inline]fn emap_get_mut<'a>(&self,map:&'a mut Self::Emap,eid:Self::Label)->&'a mut T{&mut map[eid]}}impl<T>EdgeMap<T>for SparseGraph<UndirectedEdge>{type Emap=Vec<T>;#[inline]fn construct_emap<F>(&self,f:F)->Self::Emap where F:FnMut()->T{let mut map=Vec::with_capacity(self.edges.len());map.resize_with(self.edges.len(),f);map}#[inline]fn emap_get<'a>(&self,map:&'a Self::Emap,eid:Self::Label)->&'a T{&map[eid]}#[inline]fn emap_get_mut<'a>(&self,map:&'a mut Self::Emap,eid:Self::Label)->&'a mut T{&mut map[eid]}}impl<D,T>VertexMap<T>for SparseGraph<D>where D:SparseGraphConstruction{type Vmap=Vec<T>;#[inline]fn construct_vmap<F>(&self,f:F)->Self::Vmap where F:FnMut()->T{let mut v=Vec::with_capacity(self.vsize);v.resize_with(self.vsize,f);v}#[inline]fn vmap_get<'a>(&self,map:&'a Self::Vmap,vid:Self::Vertex)->&'a T{&map[vid]}#[inline]fn vmap_get_mut<'a>(&self,map:&'a mut Self::Vmap,vid:Self::Vertex)->&'a mut T{&mut map[vid]}}}
// codesnip-guard: Xorshift
#[cfg_attr(any(),rustfmt::skip)]pub use self::xorshift::Xorshift;#[cfg_attr(any(),rustfmt::skip)]mod xorshift{use std::{collections::hash_map::RandomState,hash::{BuildHasher,Hasher},iter::repeat_with};#[derive(Clone,Debug)]pub struct Xorshift{y:u64}impl Xorshift{pub fn new_with_seed(seed:u64)->Self{Xorshift{y:seed}}pub fn new()->Self{Xorshift::new_with_seed(RandomState::new().build_hasher().finish())}pub fn rand64(&mut self)->u64{self.y^=self.y<<5;self.y^=self.y>>17;self.y^=self.y<<11;self.y}pub fn rand(&mut self,k:u64)->u64{self.rand64()%k}pub fn rands(&mut self,k:u64,n:usize)->Vec<u64>{repeat_with(| |self.rand(k)).take(n).collect()}pub fn randf(&mut self)->f64{const UPPER_MASK:u64=0x3FF0_0000_0000_0000;const LOWER_MASK:u64=0x000F_FFFF_FFFF_FFFF;let x=self.rand64();let tmp=UPPER_MASK|(x&LOWER_MASK);let result:f64=f64::from_bits(tmp);f64::from_bits(f64::to_bits(result-1.0)^(x>>63))}pub fn gen_bool(&mut self,p:f64)->bool{self.randf()<p}pub fn shuffle<T>(&mut self,slice:&mut[T]){let mut n=slice.len();while n>1{let i=self.rand(n as _)as usize;n-=1;slice.swap(i,n);}}}impl Default for Xorshift{fn default()->Self{Xorshift::new_with_seed(0x2b99_2ddf_a232_49d6)}}}
// 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: random_generator
#[cfg_attr(any(),rustfmt::skip)]pub use self::random_generator::{NotEmptySegment,RandIter,RandRange,RandomSpec,Spec,WeightedSampler,WithEmptySegment,from_fn,spec};#[cfg_attr(any(),rustfmt::skip)]mod random_generator{use super::Xorshift;use std::{marker::PhantomData,mem::swap,ops::{Bound,Range,RangeFrom,RangeFull,RangeInclusive,RangeTo,RangeToInclusive}};#[doc=" Trait for spec of generating random value."]pub trait RandomSpec<T>:Sized{#[doc=" Return a random value."]fn rand(&self,rng:&mut Xorshift)->T;#[doc=" Return an iterator that generates random values."]fn rand_iter(self,rng:&mut Xorshift)->RandIter<'_,T,Self>{RandIter{spec:self,rng,_marker:PhantomData}}}pub struct Spec<T,F>{generate:F,_marker:PhantomData<fn()->T>}#[doc=" Wraps a random specification for composition."]pub fn spec<T,R>(source:R)->Spec<T,impl Fn(&mut Xorshift)->T>where R:RandomSpec<T>{from_fn(move|rng|source.rand(rng))}#[doc=" Calls `generate` with the RNG whenever a value is requested."]pub fn from_fn<T,F>(generate:F)->Spec<T,F>where F:Fn(&mut Xorshift)->T{Spec{generate,_marker:PhantomData}}impl<T,F>Spec<T,F>where F:Fn(&mut Xorshift)->T{#[doc=" Samples the length once, then generates that many elements."]pub fn vec<R>(self,length:R)->Spec<Vec<T>,impl Fn(&mut Xorshift)->Vec<T>>where R:RandomSpec<usize>{from_fn(move|rng|{let n=rng.random(&length);rng.random_iter(&self).take(n).collect()})}}impl<T,F>RandomSpec<T>for Spec<T,F>where F:Fn(&mut Xorshift)->T{fn rand(&self,rng:&mut Xorshift)->T{(self.generate)(rng)}}impl Xorshift{pub fn random<T,R>(&mut self,spec:R)->T where R:RandomSpec<T>{spec.rand(self)}pub fn random_iter<T,R>(&mut self,spec:R)->RandIter<'_,T,R>where R:RandomSpec<T>{spec.rand_iter(self)}}#[derive(Debug)]pub struct RandIter<'r,T,R>where R:RandomSpec<T>{spec:R,rng:&'r mut Xorshift,_marker:PhantomData<fn()->T>}impl<T,R>Iterator for RandIter<'_,T,R>where R:RandomSpec<T>{type Item=T;fn next(&mut self)->Option<Self::Item>{Some(self.spec.rand(self.rng))}fn size_hint(&self)->(usize,Option<usize>){(usize::MAX,None)}}macro_rules!impl_random_spec_range_full{($($t:ty)*)=>{$(impl RandomSpec<$t>for RangeFull{fn rand(&self,rng:&mut Xorshift)->$t{rng.rand64()as _}})*};}impl_random_spec_range_full!(u8 u16 u32 u64 usize i8 i16 i32 i64 isize);impl RandomSpec<u128>for RangeFull{fn rand(&self,rng:&mut Xorshift)->u128{((rng.rand64()as u128)<<64)|rng.rand64()as u128}}impl RandomSpec<i128>for RangeFull{fn rand(&self,rng:&mut Xorshift)->i128{rng.random::<u128,_>(..)as i128}}macro_rules!impl_random_spec_ranges{($($u:ident$i:ident)*)=>{$(impl RandomSpec<$u>for Range<$u>{fn rand(&self,rng:&mut Xorshift)->$u{assert!(self.start<self.end);let len=self.end-self.start;(self.start+rng.random::<$u,_>(..)%len)}}impl RandomSpec<$i>for Range<$i>{fn rand(&self,rng:&mut Xorshift)->$i{assert!(self.start<self.end);let len=self.end.abs_diff(self.start);self.start.wrapping_add_unsigned(rng.random::<$u,_>(..)%len)}}impl RandomSpec<$u>for RangeFrom<$u>{fn rand(&self,rng:&mut Xorshift)->$u{let len=($u::MAX-self.start).wrapping_add(1);let x=rng.random::<$u,_>(..);self.start+if len!=0{x%len}else{x}}}impl RandomSpec<$i>for RangeFrom<$i>{fn rand(&self,rng:&mut Xorshift)->$i{let len=($i::MAX.abs_diff(self.start)).wrapping_add(1);let x=rng.random::<$u,_>(..);self.start.wrapping_add_unsigned(if len!=0{x%len}else{x})}}impl RandomSpec<$u>for RangeInclusive<$u>{fn rand(&self,rng:&mut Xorshift)->$u{assert!(self.start()<=self.end());let len=(self.end()-self.start()).wrapping_add(1);let x=rng.random::<$u,_>(..);self.start()+if len!=0{x%len}else{x}}}impl RandomSpec<$i>for RangeInclusive<$i>{fn rand(&self,rng:&mut Xorshift)->$i{assert!(self.start()<=self.end());let len=(self.end().abs_diff(*self.start())).wrapping_add(1);let x=rng.random::<$u,_>(..);self.start().wrapping_add_unsigned(if len!=0{x%len}else{x})}}impl RandomSpec<$u>for RangeTo<$u>{fn rand(&self,rng:&mut Xorshift)->$u{let len=self.end;rng.random::<$u,_>(..)%len}}impl RandomSpec<$i>for RangeTo<$i>{fn rand(&self,rng:&mut Xorshift)->$i{let len=self.end.abs_diff($i::MIN);$i::MIN.wrapping_add_unsigned(rng.random::<$u,_>(..)%len)}}impl RandomSpec<$u>for RangeToInclusive<$u>{fn rand(&self,rng:&mut Xorshift)->$u{let len=(self.end).wrapping_add(1);let x=rng.random::<$u,_>(..);if len!=0{x%len}else{x}}}impl RandomSpec<$i>for RangeToInclusive<$i>{fn rand(&self,rng:&mut Xorshift)->$i{let len=(self.end.abs_diff($i::MIN)).wrapping_add(1);let x=rng.random::<$u,_>(..);$i::MIN.wrapping_add_unsigned(if len!=0{x%len}else{x})}})*};}impl_random_spec_ranges!(u8 i8 u16 i16 u32 i32 u64 i64 u128 i128 usize isize);macro_rules!impl_random_spec_tuple{($($T:ident)*,$($R:ident)*,$($v:ident)*)=>{impl<$($T),*,$($R),*>RandomSpec<($($T,)*)>for($($R,)*)where$($R:RandomSpec<$T>),*{fn rand(&self,rng:&mut Xorshift)->($($T,)*){let($($v,)*)=self;($(($v).rand(rng),)*)}}};}impl_random_spec_tuple!(A,RA,a);impl_random_spec_tuple!(A B,RA RB,a b);impl_random_spec_tuple!(A B C,RA RB RC,a b c);impl_random_spec_tuple!(A B C D,RA RB RC RD,a b c d);impl_random_spec_tuple!(A B C D E,RA RB RC RD RE,a b c d e);impl_random_spec_tuple!(A B C D E F,RA RB RC RD RE RF,a b c d e f);impl_random_spec_tuple!(A B C D E F G,RA RB RC RD RE RF RG,a b c d e f g);impl_random_spec_tuple!(A B C D E F G H,RA RB RC RD RE RF RG RH,a b c d e f g h);impl_random_spec_tuple!(A B C D E F G H I,RA RB RC RD RE RF RG RH RI,a b c d e f g h i);impl_random_spec_tuple!(A B C D E F G H I J,RA RB RC RD RE RF RG RH RI RJ,a b c d e f g h i j);macro_rules!impl_random_spec_primitive{($($t:ty)*)=>{$(impl RandomSpec<$t>for$t{fn rand(&self,_rng:&mut Xorshift)->$t{*self}})*};}impl_random_spec_primitive!(()u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize bool char);impl<T,R>RandomSpec<T>for&R where R:RandomSpec<T>{fn rand(&self,rng:&mut Xorshift)->T{<R as RandomSpec<T>>::rand(self,rng)}}impl<T,R>RandomSpec<T>for&mut R where R:RandomSpec<T>{fn rand(&self,rng:&mut Xorshift)->T{<R as RandomSpec<T>>::rand(self,rng)}}#[derive(Debug,Clone,Copy,PartialEq,Eq,PartialOrd,Ord,Hash)]#[doc=" Left-close Right-open No Empty Segment"]pub struct NotEmptySegment<T>(pub T);impl<T>RandomSpec<(usize,usize)>for NotEmptySegment<T>where T:RandomSpec<usize>{fn rand(&self,rng:&mut Xorshift)->(usize,usize){let n=rng.random(&self.0)as u64;let k=randint_uniform(rng,n);let l=randint_uniform(rng,n-k)as usize;(l,l+k as usize+1)}}#[derive(Debug,Clone,Copy,PartialEq,Eq,PartialOrd,Ord,Hash)]#[doc=" Left-close Right-open Segment"]pub struct WithEmptySegment<T>(pub T);impl<T>RandomSpec<(usize,usize)>for WithEmptySegment<T>where T:RandomSpec<usize>{fn rand(&self,rng:&mut Xorshift)->(usize,usize){let n=rng.random(&self.0)as u64;let k=randint_uniform(rng,n+1);let l=randint_uniform(rng,n-k+1)as usize;(l,l+k as usize)}}#[derive(Debug,Clone,Copy,PartialEq,Eq,PartialOrd,Ord,Hash)]pub struct RandRange<Q,T>{data:Q,_marker:PhantomData<fn()->T>}impl<Q,T>RandRange<Q,T>{pub fn new(data:Q)->Self{Self{data,_marker:PhantomData}}}impl<Q,T>RandomSpec<(Bound<T>,Bound<T>)>for RandRange<Q,T>where Q:RandomSpec<T>,T:Ord{fn rand(&self,rng:&mut Xorshift)->(Bound<T>,Bound<T>){let mut l=rng.random(&self.data);let mut r=rng.random(&self.data);if l>r{swap(&mut l,&mut r);}(match rng.rand(3){0=>Bound::Excluded(l),1=>Bound::Included(l),_=>Bound::Unbounded,},match rng.rand(3){0=>Bound::Excluded(r),1=>Bound::Included(r),_=>Bound::Unbounded,})}}#[inline]fn randint_uniform(rng:&mut Xorshift,k:u64)->u64{let mut v=rng.rand64();if k>0{v%=k;}v}pub struct WeightedSampler{n:usize,prob:Vec<f64>,alias:Vec<usize>}impl WeightedSampler{pub fn new(weights:impl IntoIterator<Item=f64>)->Self{let mut weights:Vec<_>=weights.into_iter().collect();let n=weights.len();assert!(n>0,"weights must be non-empty");let mut prob=vec![0.0;n];let mut alias=vec![0;n];let mut small=vec![];let mut large=vec![];let sum:f64=weights.iter().sum();assert!(sum>0.0,"sum of weights must be positive");let mut scale=n as f64/sum;if!sum.is_finite()||!scale.is_finite(){let max=weights.iter().fold(0.0f64,|max,&weight|{assert!(weight.is_finite()&&weight>=0.0,"weights must be finite and non-negative");max.max(weight)});let sum:f64=weights.iter_mut().map(|weight|{*weight/=max;*weight}).sum();scale=n as f64/sum;}for(i,weight)in weights.iter_mut().enumerate(){assert!(*weight>=0.0,"weights must be non-negative");*weight*=scale;if*weight<1.0{small.push(i);}else{large.push(i);}}while let Some(&g)=large.last(){let Some(l)=small.pop()else{break;};prob[l]=weights[l];alias[l]=g;weights[g]-=1.0-weights[l];if weights[g]<1.0{large.pop();small.push(g);}}for g in small.into_iter().chain(large).rev(){prob[g]=1.0;alias[g]=g;}Self{n,prob,alias}}}impl RandomSpec<usize>for WeightedSampler{fn rand(&self,rng:&mut Xorshift)->usize{let i=rng.rand(self.n as u64)as usize;if rng.randf()<self.prob[i]{i}else{self.alias[i]}}}#[macro_export]#[doc=" Return a random value using [`RandomSpec`]."]#[doc=""]#[doc=" ```"]#[doc=" use competitive::tools::Xorshift;"]#[doc=""]#[doc=" let mut rng = Xorshift::new_with_seed(42);"]#[doc=" let values: Vec<u32> = competitive::rand_value!(rng, [0..10; 4]);"]#[doc=" assert_eq!(values.len(), 4);"]#[doc=" assert!(values.into_iter().all(|value| value < 10));"]#[doc=" ```"]macro_rules!rand_value{(@repeat$rng:expr,[$($t:tt)*]$($len:expr)?)=>{::std::iter::repeat_with(||$crate::rand_value!(@inner$rng,[]$($t)*))$(.take($len).collect::<::std::vec::Vec<_>>())?};(@array$rng:expr,[$($t:tt)*]$len:expr)=>{{let values:[_;$len]=::std::array::from_fn(|_|$crate::rand_value!(@inner$rng,[]$($t)*));values}};(@group$rng:expr,[])=>{()};(@group$rng:expr,[$($args:tt)*],$($t:tt)*)=>{$crate::rand_value!(@tuple$rng,[$($args)*]$($t)*)};(@tuple$rng:expr,[$([$($args:tt)*])*])=>{($($($args)*,)*)};(@$tag:ident$rng:expr,[[$($args:tt)*]])=>{$($args)*};(@$tag:ident$rng:expr,[$($args:tt)*]($($tuple:tt)*)$(,$($t:tt)*)?)=>{$crate::rand_value!(@$tag$rng,[$($args)*[$crate::rand_value!(@group$rng,[]$($tuple)*)]]$(,$($t)*)?)};(@$tag:ident$rng:expr,[$($args:tt)*][[$($tt:tt)*];const$len:expr]$(,$($t:tt)*)?)=>{$crate::rand_value!(@$tag$rng,[$($args)*[$crate::rand_value!(@array$rng,[[$($tt)*]]$len)]]$(,$($t)*)?)};(@$tag:ident$rng:expr,[$($args:tt)*][[$($tt:tt)*];$len:expr]$(,$($t:tt)*)?)=>{$crate::rand_value!(@$tag$rng,[$($args)*[$crate::rand_value!(@repeat$rng,[[$($tt)*]]$len)]]$(,$($t)*)?)};(@$tag:ident$rng:expr,[$($args:tt)*][($($tt:tt)*);const$len:expr]$(,$($t:tt)*)?)=>{$crate::rand_value!(@$tag$rng,[$($args)*[$crate::rand_value!(@array$rng,[($($tt)*)]$len)]]$(,$($t)*)?)};(@$tag:ident$rng:expr,[$($args:tt)*][($($tt:tt)*);$len:expr]$(,$($t:tt)*)?)=>{$crate::rand_value!(@$tag$rng,[$($args)*[$crate::rand_value!(@repeat$rng,[($($tt)*)]$len)]]$(,$($t)*)?)};(@$tag:ident$rng:expr,[$($args:tt)*][$ty:expr;const$len:expr]$(,$($t:tt)*)?)=>{$crate::rand_value!(@$tag$rng,[$($args)*[$crate::rand_value!(@array$rng,[$ty]$len)]]$(,$($t)*)?)};(@$tag:ident$rng:expr,[$($args:tt)*][$ty:expr;$len:expr]$(,$($t:tt)*)?)=>{$crate::rand_value!(@$tag$rng,[$($args)*[$crate::rand_value!(@repeat$rng,[$ty]$len)]]$(,$($t)*)?)};(@$tag:ident$rng:expr,[$($args:tt)*][$($tt:tt)*]$(,$($t:tt)*)?)=>{$crate::rand_value!(@$tag$rng,[$($args)*[$crate::rand_value!(@repeat$rng,[$($tt)*])]]$(,$($t)*)?)};(@$tag:ident$rng:expr,[$($args:tt)*]$ty:expr)=>{$crate::rand_value!(@$tag$rng,[$($args)*[($rng).random($ty)]])};(@$tag:ident$rng:expr,[$($args:tt)*]$ty:expr,$($t:tt)*)=>{$crate::rand_value!(@$tag$rng,[$($args)*[($rng).random($ty)]],$($t)*)};(@$tag:ident$rng:expr,[$($args:tt)*],$($t:tt)*)=>{$crate::rand_value!(@$tag$rng,[$($args)*]$($t)*)};(@$tag:ident$rng:expr,[$($args:tt)*])=>{::std::compile_error!(::std::stringify!($($args)*))};($rng:expr,$($t:tt)*)=>{$crate::rand_value!(@inner$rng,[]$($t)*)}}#[macro_export]#[doc=" Declare random values using [`RandomSpec`]."]macro_rules!rand{(@assert$p:pat)=>{};(@assert$($p:tt)*)=>{::std::compile_error!(::std::concat!("expected pattern, found `",::std::stringify!($($p)*),"`"));};(@pat$rng:expr,[][])=>{};(@pat$rng:expr,[][],$($t:tt)*)=>{$crate::rand!(@pat$rng,[][]$($t)*)};(@pat$rng:expr,[$($p:tt)*][]$x:ident$($t:tt)*)=>{$crate::rand!(@pat$rng,[$($p)*$x][]$($t)*)};(@pat$rng:expr,[$($p:tt)*][]::$($t:tt)*)=>{$crate::rand!(@pat$rng,[$($p)*::][]$($t)*)};(@pat$rng:expr,[$($p:tt)*][]&$($t:tt)*)=>{$crate::rand!(@pat$rng,[$($p)*&][]$($t)*)};(@pat$rng:expr,[$($p:tt)*][]($($x:tt)*)$($t:tt)*)=>{$crate::rand!(@pat$rng,[$($p)*($($x)*)][]$($t)*)};(@pat$rng:expr,[$($p:tt)*][][$($x:tt)*]$($t:tt)*)=>{$crate::rand!(@pat$rng,[$($p)*[$($x)*]][]$($t)*)};(@pat$rng:expr,[$($p:tt)*][]{$($x:tt)*}$($t:tt)*)=>{$crate::rand!(@pat$rng,[$($p)*{$($x)*}][]$($t)*)};(@pat$rng:expr,[$($p:tt)*][]:$($t:tt)*)=>{$crate::rand!(@ty$rng,[$($p)*][]$($t)*)};(@ty$rng:expr,[$($p:tt)*][$($tt:tt)*]($($x:tt)*)$(,$($t:tt)*)?)=>{$crate::rand!(@let$rng,[$($p)*][$($tt)*($($x)*)]$(,$($t)*)?)};(@ty$rng:expr,[$($p:tt)*][$($tt:tt)*][$($x:tt)*]$(,$($t:tt)*)?)=>{$crate::rand!(@let$rng,[$($p)*][$($tt)*[$($x)*]]$(,$($t)*)?)};(@ty$rng:expr,[$($p:tt)*][$($tt:tt)*]$e:expr)=>{$crate::rand!(@let$rng,[$($p)*][$($tt)*$e])};(@ty$rng:expr,[$($p:tt)*][$($tt:tt)*]$e:expr,$($t:tt)*)=>{$crate::rand!(@let$rng,[$($p)*][$($tt)*$e],$($t)*)};(@ty$rng:expr,[$($p:tt)*][$($tt:tt)*]$e:tt)=>{$crate::rand!(@let$rng,[$($p)*][$($tt)*$e])};(@ty$rng:expr,[$($p:tt)*][$($tt:tt)*]$e:tt,$($t:tt)*)=>{$crate::rand!(@let$rng,[$($p)*][$($tt)*$e],$($t)*)};(@let$rng:expr,[$($p:tt)*][$($tt:tt)*]$($t:tt)*)=>{$crate::rand!{@assert$($p)*}let$($p)* =$crate::rand_value!($rng,$($tt)*);$crate::rand!(@pat$rng,[][]$($t)*)};($rng:expr)=>{};($rng:expr,$($t:tt)*)=>{$crate::rand!(@pat$rng,[][]$($t)*)};}}
// codesnip-guard: scanner
#[cfg_attr(any(),rustfmt::skip)]pub use self::scanner::*;#[cfg_attr(any(),rustfmt::skip)]mod scanner{use std::{iter::{FromIterator,from_fn,repeat_with},marker::PhantomData};pub fn read_stdin_all()->String{use std::io::Read as _;let mut s=String::new();std::io::stdin().read_to_string(&mut s).expect("io error");s}pub fn read_stdin_all_unchecked()->String{use std::io::Read as _;let mut buf=Vec::new();std::io::stdin().read_to_end(&mut buf).expect("io error");unsafe{String::from_utf8_unchecked(buf)}}pub fn read_all(mut reader:impl std::io::Read)->String{let mut s=String::new();reader.read_to_string(&mut s).expect("io error");s}pub fn read_all_unchecked(mut reader:impl std::io::Read)->String{let mut buf=Vec::new();reader.read_to_end(&mut buf).expect("io error");unsafe{String::from_utf8_unchecked(buf)}}pub fn read_stdin_line()->String{let mut s=String::new();std::io::stdin().read_line(&mut s).expect("io error");s}pub trait Scan:Sized{type Output;fn scan<S:ScanSource>(source:&mut S)->Option<Self::Output>;fn scan_vec<S:ScanSource>(source:&mut S,size:usize,capacity:usize)->Vec<Self::Output>{let mut values=Vec::with_capacity(capacity.max(size));values.extend((0..size).map(|_|source.scan::<Self>()));values}}pub trait MarkedScan:Sized{type Output;fn mscan<S:ScanSource>(self,source:&mut S)->Option<Self::Output>;}pub trait ScanSource:Sized{#[doc=" Reads a token under the source's input requirements."]#[doc=" Checked sources return `None` at EOF; unchecked sources require available input."]fn next_token(&mut self)->Option<&str>;#[doc=" Skips separators without consuming the next token."]#[inline]fn skip_whitespace(&mut self){}#[inline]fn read_u8(&mut self)->Option<u8>{self.next_token()?.parse().ok()}#[inline]fn read_u16(&mut self)->Option<u16>{self.next_token()?.parse().ok()}#[inline]fn read_u32(&mut self)->Option<u32>{self.next_token()?.parse().ok()}fn read_u32_vec(&mut self,size:usize,capacity:usize)->Vec<u32>{let mut values=Vec::with_capacity(capacity.max(size));values.extend((0..size).map(|_|self.scan::<u32>()));values}#[inline]fn read_u64(&mut self)->Option<u64>{self.next_token()?.parse().ok()}#[inline]fn read_u128(&mut self)->Option<u128>{self.next_token()?.parse().ok()}#[inline]fn read_usize(&mut self)->Option<usize>{self.next_token()?.parse().ok()}#[inline]fn read_i8(&mut self)->Option<i8>{self.next_token()?.parse().ok()}#[inline]fn read_i16(&mut self)->Option<i16>{self.next_token()?.parse().ok()}#[inline]fn read_i32(&mut self)->Option<i32>{self.next_token()?.parse().ok()}#[inline]fn read_i64(&mut self)->Option<i64>{self.next_token()?.parse().ok()}#[inline]fn read_i128(&mut self)->Option<i128>{self.next_token()?.parse().ok()}#[inline]fn read_isize(&mut self)->Option<isize>{self.next_token()?.parse().ok()}#[doc=" Panics if reading fails."]#[inline]fn scan<T:Scan>(&mut self)->T::Output{T::scan(self).expect("scan error")}#[doc=" Panics if reading fails."]#[inline]fn mscan<T:MarkedScan>(&mut self,marker:T)->T::Output{marker.mscan(self).expect("scan error")}fn scan_vec<T:Scan>(&mut self,size:usize,capacity:usize)->Vec<T::Output>{if size==0{self.skip_whitespace();}T::scan_vec(self,size,capacity)}#[inline]fn iter<T:Scan>(&mut self)->ScannerIter<'_,Self,T>{ScannerIter{inner:self,_marker:PhantomData}}}#[derive(Clone,Debug)]pub struct Scanner<'a,I:Iterator<Item=&'a str>=std::str::SplitAsciiWhitespace<'a>>{iter:I}impl<'a>Scanner<'a>{pub fn new(s:&'a str)->Self{Self{iter:s.split_ascii_whitespace()}}}impl<'a,I:Iterator<Item=&'a str>>Scanner<'a,I>{pub fn new_from_iter(iter:I)->Self{Self{iter}}}impl<'a,I:Iterator<Item=&'a str>>ScanSource for Scanner<'a,I>{fn next_token(&mut self)->Option<&str>{self.iter.next()}}macro_rules!impl_scan{($($t:ty)*)=>{$(impl Scan for$t{type Output=Self;fn scan<I:ScanSource>(iter:&mut I)->Option<Self>{iter.next_token()?.parse::<$t>().ok()}})*};}impl_scan!(char f32 f64 String);macro_rules!impl_integer_scan{($($t:ty=>$read:ident),*$(,)?)=>{$(impl Scan for$t{type Output=Self;#[inline]fn scan<S:ScanSource>(source:&mut S)->Option<Self>{source.$read()}})*};}impl_integer_scan!(u8=>read_u8,u16=>read_u16,u64=>read_u64,u128=>read_u128,usize=>read_usize,i8=>read_i8,i16=>read_i16,i32=>read_i32,i64=>read_i64,i128=>read_i128,isize=>read_isize,);impl Scan for u32{type Output=Self;#[inline]fn scan<S:ScanSource>(source:&mut S)->Option<Self>{source.read_u32()}fn scan_vec<S:ScanSource>(source:&mut S,size:usize,capacity:usize)->Vec<Self>{source.read_u32_vec(size,capacity)}}macro_rules!impl_scan_tuple{(@impl$($T:ident)*)=>{impl<$($T:Scan),*>Scan for($($T,)*){type Output=($(<$T as Scan>::Output,)*);fn scan<It:ScanSource>(_iter:&mut It)->Option<Self::Output>{Some(($(<$T as Scan>::scan(_iter)?,)*))}}};(@inner$($T:ident)*,)=>{impl_scan_tuple!(@impl$($T)*);};(@inner$($T:ident)*,$U:ident$($Rest:ident)*)=>{impl_scan_tuple!(@impl$($T)*);impl_scan_tuple!(@inner$($T)*$U,$($Rest)*);};($($T:ident)*)=>{impl_scan_tuple!(@inner,$($T)*);};}impl_scan_tuple!(A B C D E F G H I J K);pub struct ScannerIter<'a,S,T>{inner:&'a mut S,_marker:PhantomData<fn()->T>}impl<S:ScanSource,T:Scan>Iterator for ScannerIter<'_,S,T>{type Item=T::Output;#[inline]fn next(&mut self)->Option<Self::Item>{T::scan(self.inner)}}#[doc=" scan a value with Scanner"]#[doc=""]#[doc=" - `scan_value!(scanner, ELEMENT)`"]#[doc=""]#[doc=" ELEMENT :="]#[doc=" - `$ty`: Scan"]#[doc=" - `&str`: borrowed token; the source stays borrowed until its last use"]#[doc=" - `@$expr`: MarkedScan"]#[doc=" - `$ty = $expr`: MarkedScan"]#[doc=" - `[ELEMENT; $expr]`: vector"]#[doc=" - `[$ty; $len; capacity $capacity]`: vector with reserved capacity"]#[doc=" - `[ELEMENT; const $expr]`: array"]#[doc=" - `[ELEMENT]`: iterator"]#[doc=" - `[ELEMENT; iter $expr]`: iterator of the specified length"]#[doc=" - `($(ELEMENT)*,)`: tuple"]#[macro_export]macro_rules!scan_value{(@repeat$scanner:expr,[$($t:tt)*]$len:expr)=>{{$crate::scan_value!(@iter$scanner,[$($t)*]$len).collect::<Vec<_>>()}};(@repeat$scanner:expr,[$($t:tt)*])=>{{::std::iter::repeat_with(||$crate::scan_value!(@inner$scanner,[]$($t)*))}};(@iter$scanner:expr,[$($t:tt)*]$len:expr)=>{{let size=$len;if size==0{$scanner.skip_whitespace();}$crate::scan_value!(@repeat$scanner,[$($t)*]).take(size)}};(@array$scanner:expr,[$($t:tt)*]$len:expr)=>{{if$len==0{$scanner.skip_whitespace();}$crate::array![||$crate::scan_value!(@inner$scanner,[]$($t)*);$len]}};(@tuple$scanner:expr,[$([$($args:tt)*])*])=>{($($($args)*,)*)};(@sparen$scanner:expr,[]@$e:expr;$($t:tt)*)=>{$crate::scan_value!(@sparen$scanner,[@$e]$($t)*)};(@sparen$scanner:expr,[]($($tt:tt)*);$($t:tt)*)=>{$crate::scan_value!(@sparen$scanner,[($($tt)*)]$($t)*)};(@sparen$scanner:expr,[][$($tt:tt)*];$($t:tt)*)=>{$crate::scan_value!(@sparen$scanner,[[$($tt)*]]$($t)*)};(@sparen$scanner:expr,[]$ty:ty=$e:expr;$($t:tt)*)=>{$crate::scan_value!(@sparen$scanner,[$ty=$e]$($t)*)};(@sparen$scanner:expr,[]$ty:ty;$($t:tt)*)=>{$crate::scan_value!(@sparen$scanner,[$ty]$($t)*)};(@sparen$scanner:expr,[]$($args:tt)*)=>{$crate::scan_value!(@repeat$scanner,[$($args)*])};(@sparen$scanner:expr,[$($args:tt)+]const$len:expr)=>{$crate::scan_value!(@array$scanner,[$($args)+]$len)};(@sparen$scanner:expr,[$($args:tt)+]iter$len:expr)=>{$crate::scan_value!(@iter$scanner,[$($args)+]$len)};(@sparen$scanner:expr,[$($args:tt)+]$len:expr;capacity$capacity:expr)=>{{let size=$len;let capacity=$capacity;$scanner.scan_vec::<$($args)+>(size,capacity)}};(@sparen$scanner:expr,[$($args:tt)+]$len:expr)=>{$crate::scan_value!(@repeat$scanner,[$($args)+]$len)};(@$tag:ident$scanner:expr,[[$($args:tt)*]])=>{$($args)*};(@$tag:ident$scanner:expr,[$($args:tt)*]@$e:expr$(,$($t:tt)*)?)=>{$crate::scan_value!(@$tag$scanner,[$($args)*[$scanner.mscan($e)]]$(,$($t)*)?)};(@$tag:ident$scanner:expr,[$($args:tt)*]($($tuple:tt)*)$($t:tt)*)=>{$crate::scan_value!(@$tag$scanner,[$($args)*[$crate::scan_value!(@tuple$scanner,[]$($tuple)*)]]$($t)*)};(@$tag:ident$scanner:expr,[$($args:tt)*][$($tt:tt)*]$($t:tt)*)=>{$crate::scan_value!(@$tag$scanner,[$($args)*[$crate::scan_value!(@sparen$scanner,[]$($tt)*)]]$($t)*)};(@$tag:ident$scanner:expr,[$($args:tt)*]&str$(,$($t:tt)*)?)=>{$crate::scan_value!(@$tag$scanner,[$($args)*[$scanner.next_token().expect("scan error")]]$(,$($t)*)?)};(@$tag:ident$scanner:expr,[$($args:tt)*]$ty:ty=$e:expr$(,$($t:tt)*)?)=>{$crate::scan_value!(@$tag$scanner,[$($args)*[{let _tmp:$ty=$scanner.mscan($e);_tmp}]]$(,$($t)*)?)};(@$tag:ident$scanner:expr,[$($args:tt)*]$ty:ty$(,$($t:tt)*)?)=>{$crate::scan_value!(@$tag$scanner,[$($args)*[$scanner.scan::<$ty>()]]$(,$($t)*)?)};(@$tag:ident$scanner:expr,[$($args:tt)*],$($t:tt)*)=>{$crate::scan_value!(@$tag$scanner,[$($args)*]$($t)*)};(@$tag:ident$scanner:expr,[$($args:tt)*])=>{::std::compile_error!(::std::stringify!($($args)*))};(src=$src:expr,$($t:tt)*)=>{{let mut __scanner=Scanner::new($src);$crate::scan_value!(@inner __scanner,[]$($t)*)}};(iter=$iter:expr,$($t:tt)*)=>{{let mut __scanner=Scanner::new_from_iter($iter);$crate::scan_value!(@inner __scanner,[]$($t)*)}};($scanner:expr,$($t:tt)*)=>{$crate::scan_value!(@inner$scanner,[]$($t)*)}}#[doc=" scan and bind values with Scanner"]#[doc=""]#[doc=" - `scan!(scanner, $($pat $(: ELEMENT)?),*)`"]#[macro_export]macro_rules!scan{(@assert$p:pat)=>{};(@assert$($p:tt)*)=>{::std::compile_error!(::std::concat!("expected pattern, found `",::std::stringify!($($p)*),"`"));};(@pat$scanner:expr,[][])=>{};(@pat$scanner:expr,[][],$($t:tt)*)=>{$crate::scan!(@pat$scanner,[][]$($t)*)};(@pat$scanner:expr,[$($p:tt)*][]$x:ident$($t:tt)*)=>{$crate::scan!(@pat$scanner,[$($p)*$x][]$($t)*)};(@pat$scanner:expr,[$($p:tt)*][]::$($t:tt)*)=>{$crate::scan!(@pat$scanner,[$($p)*::][]$($t)*)};(@pat$scanner:expr,[$($p:tt)*][]&$($t:tt)*)=>{$crate::scan!(@pat$scanner,[$($p)*&][]$($t)*)};(@pat$scanner:expr,[$($p:tt)*][]($($x:tt)*)$($t:tt)*)=>{$crate::scan!(@pat$scanner,[$($p)*($($x)*)][]$($t)*)};(@pat$scanner:expr,[$($p:tt)*][][$($x:tt)*]$($t:tt)*)=>{$crate::scan!(@pat$scanner,[$($p)*[$($x)*]][]$($t)*)};(@pat$scanner:expr,[$($p:tt)*][]{$($x:tt)*}$($t:tt)*)=>{$crate::scan!(@pat$scanner,[$($p)*{$($x)*}][]$($t)*)};(@pat$scanner:expr,[$($p:tt)*][]:$($t:tt)*)=>{$crate::scan!(@ty$scanner,[$($p)*][]$($t)*)};(@pat$scanner:expr,[$($p:tt)*][]$($t:tt)*)=>{$crate::scan!(@let$scanner,[$($p)*][usize]$($t)*)};(@ty$scanner:expr,[$($p:tt)*][$($tt:tt)*]@$e:expr$(,$($t:tt)*)?)=>{$crate::scan!(@let$scanner,[$($p)*][$($tt)*@$e]$(,$($t)*)?)};(@ty$scanner:expr,[$($p:tt)*][$($tt:tt)*]($($x:tt)*)$($t:tt)*)=>{$crate::scan!(@let$scanner,[$($p)*][$($tt)*($($x)*)]$($t)*)};(@ty$scanner:expr,[$($p:tt)*][$($tt:tt)*][$($x:tt)*]$($t:tt)*)=>{$crate::scan!(@let$scanner,[$($p)*][$($tt)*[$($x)*]]$($t)*)};(@ty$scanner:expr,[$($p:tt)*][$($tt:tt)*]&str$(,$($t:tt)*)?)=>{$crate::scan!(@let$scanner,[$($p)*][$($tt)*&str]$(,$($t)*)?)};(@ty$scanner:expr,[$($p:tt)*][$($tt:tt)*]$ty:ty=$e:expr$(,$($t:tt)*)?)=>{$crate::scan!(@let$scanner,[$($p)*][$($tt)*$ty=$e]$(,$($t)*)?)};(@ty$scanner:expr,[$($p:tt)*][$($tt:tt)*]$ty:ty$(,$($t:tt)*)?)=>{$crate::scan!(@let$scanner,[$($p)*][$($tt)*$ty]$(,$($t)*)?)};(@let$scanner:expr,[$($p:tt)*][$($tt:tt)*]$($t:tt)*)=>{$crate::scan!{@assert$($p)*}let$($p)* =$crate::scan_value!($scanner,$($tt)*);$crate::scan!(@pat$scanner,[][]$($t)*)};(src=$src:expr,$($t:tt)*)=>{let mut __scanner=Scanner::new($src);$crate::scan!(@pat __scanner,[][]$($t)*)};(iter=$iter:expr,$($t:tt)*)=>{let mut __scanner=Scanner::new_from_iter($iter);$crate::scan!(@pat __scanner,[][]$($t)*)};($scanner:expr,$($t:tt)*)=>{$crate::scan!(@pat$scanner,[][]$($t)*)}}#[doc=" define enum scan rules"]#[doc=""]#[doc=" # Example"]#[doc=" ```rust"]#[doc=" # use competitive::{define_enum_scan, tools::{CharsWithBase, Scan, ScanSource, Scanner, Usize1}};"]#[doc=" define_enum_scan! {"]#[doc="   enum Query: u8 {"]#[doc="     0 => Noop,"]#[doc="     1 => Args { i: Usize1, s: char },"]#[doc="     9 => Complex { n: usize, c: [(usize, Vec<usize> = CharsWithBase('a')); n] },"]#[doc="   }"]#[doc=" }"]#[doc=" ```"]#[macro_export]macro_rules!define_enum_scan{(@field_ty@repeat[$($t:tt)*]$($len:expr)?)=>{Vec<$crate::define_enum_scan!(@field_ty$($t)*)>};(@field_ty@array[$($t:tt)*]$len:expr)=>{[$crate::define_enum_scan!(@field_ty$($t)*);$len]};(@field_ty@tuple[$([$($args:tt)*])*])=>{($($($args)*,)*)};(@field_ty@sparen[]($($tt:tt)*);$($t:tt)*)=>{$crate::define_enum_scan!(@field_ty@sparen[($($tt)*)]$($t)*)};(@field_ty@sparen[][$($tt:tt)*];$($t:tt)*)=>{$crate::define_enum_scan!(@field_ty@sparen[[$($tt)*]]$($t)*)};(@field_ty@sparen[]$ty:ty=$e:expr;$($t:tt)*)=>{$crate::define_enum_scan!(@field_ty@sparen[$ty=$e]$($t)*)};(@field_ty@sparen[]$ty:ty;$($t:tt)*)=>{$crate::define_enum_scan!(@field_ty@sparen[$ty]$($t)*)};(@field_ty@sparen[]$($args:tt)*)=>{$crate::define_enum_scan!(@field_ty@repeat[$($args)*])};(@field_ty@sparen[$($args:tt)+]const$len:expr)=>{$crate::define_enum_scan!(@field_ty@array[$($args)+]$len)};(@field_ty@sparen[$($args:tt)+]$len:expr)=>{$crate::define_enum_scan!(@field_ty@repeat[$($args)+]$len)};(@field_ty@$tag:ident[$($args:tt)*]($($tuple:tt)*)$($t:tt)*)=>{$crate::define_enum_scan!(@field_ty@$tag[$($args)*[$crate::define_enum_scan!(@field_ty@tuple[]$($tuple)*)]]$($t)*)};(@field_ty@$tag:ident[$($args:tt)*][$($tt:tt)*]$($t:tt)*)=>{$crate::define_enum_scan!(@field_ty@$tag[$($args)*[$crate::define_enum_scan!(@field_ty@sparen[]$($tt)*)]]$($t)*)};(@field_ty@$tag:ident[$($args:tt)*]$ty:ty=$e:expr$(,$($t:tt)*)?)=>{$crate::define_enum_scan!(@field_ty@$tag[$($args)*[$ty]]$(,$($t)*)?)};(@field_ty@$tag:ident[$($args:tt)*]$ty:ty$(,$($t:tt)*)?)=>{$crate::define_enum_scan!(@field_ty@$tag[$($args)*[<$ty as Scan>::Output]]$(,$($t)*)?)};(@field_ty@$tag:ident[$($args:tt)*],$($t:tt)*)=>{$crate::define_enum_scan!(@field_ty@$tag[$($args)*]$($t)*)};(@field_ty@$tag:ident[[$($args:tt)*]])=>{$($args)*};(@field_ty@$tag:ident[$($args:tt)*])=>{::std::compile_error!(::std::stringify!($($args)*))};(@field_ty$($t:tt)*)=>{$crate::define_enum_scan!(@field_ty@inner[]$($t)*)};(@tag_expr raw,$iter:ident)=>{ScanSource::next_token($iter)?};(@tag_expr$d:ty,$iter:ident)=>{<$d as Scan>::scan($iter)?};(@variant([$($attr:tt)*]$vis:vis$T:ident$d:tt)[$($vars:tt)*])=>{$crate::define_enum_scan!{@def$($attr)*$vis enum$T:$d{$($vars)*}}};(@variant$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident{$($fs:tt)*}$($rest:tt)*)=>{$crate::define_enum_scan!{@field$ctx[$($vars)*]$p=>$v[]$($fs)*;$($rest)*}};(@variant$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident$($rest:tt)*)=>{$crate::define_enum_scan!{@variant$ctx[$($vars)*$p=>$v,]$($rest)*}};(@variant$ctx:tt[$($vars:tt)*],$($rest:tt)*)=>{$crate::define_enum_scan!{@variant$ctx[$($vars)*]$($rest)*}};(@endfield$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident[$($fs:tt)*][$f:ident:$($spec:tt)*],$($rest:tt)*)=>{$crate::define_enum_scan!{@field$ctx[$($vars)*]$p=>$v[$($fs)*[$f:$($spec)*]]$($rest)*}};(@endfield$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident[$($fs:tt)*][$f:ident:$($spec:tt)*];$($rest:tt)*)=>{$crate::define_enum_scan!{@variant$ctx[$($vars)*$p=>$v{$($fs)*[$f:$($spec)*]},]$($rest)*}};(@field$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident[$($fs:tt)*];$($rest:tt)*)=>{$crate::define_enum_scan!{@variant$ctx[$($vars)*$p=>$v{$($fs)*},]$($rest)*}};(@field$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident[$($fs:tt)*]$f:ident:($($tuple:tt)*)$sep:tt$($rest:tt)*)=>{$crate::define_enum_scan!{@endfield$ctx[$($vars)*]$p=>$v[$($fs)*][$f:($($tuple)*)]$sep$($rest)*}};(@field$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident[$($fs:tt)*]$f:ident:[$($x:tt)*]$sep:tt$($rest:tt)*)=>{$crate::define_enum_scan!{@endfield$ctx[$($vars)*]$p=>$v[$($fs)*][$f:[$($x)*]]$sep$($rest)*}};(@field$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident[$($fs:tt)*]$f:ident:$ty:ty=$e:expr,$($rest:tt)*)=>{$crate::define_enum_scan!{@endfield$ctx[$($vars)*]$p=>$v[$($fs)*][$f:$ty=$e],$($rest)*}};(@field$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident[$($fs:tt)*]$f:ident:$ty:ty;$($rest:tt)*)=>{$crate::define_enum_scan!{@endfield$ctx[$($vars)*]$p=>$v[$($fs)*][$f:$ty];$($rest)*}};(@field$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident[$($fs:tt)*]$f:ident:$ty:ty=$e:expr;$($rest:tt)*)=>{$crate::define_enum_scan!{@endfield$ctx[$($vars)*]$p=>$v[$($fs)*][$f:$ty=$e];$($rest)*}};(@field$ctx:tt[$($vars:tt)*]$p:pat=>$v:ident[$($fs:tt)*]$f:ident:$ty:ty,$($rest:tt)*)=>{$crate::define_enum_scan!{@endfield$ctx[$($vars)*]$p=>$v[$($fs)*][$f:$ty],$($rest)*}};(@def$(#[$attr:meta])*$vis:vis enum$T:ident:$d:tt{$($p:pat=>$v:ident$({$([$f:ident:$($spec:tt)*])*})?,)*})=>{$(#[$attr])*$vis enum$T{$($v$({$($f:$crate::define_enum_scan!(@field_ty$($spec)*)),*})?),*}impl Scan for$T{type Output=Self;fn scan<I:ScanSource>(iter:&mut I)->Option<Self>{let tag=$crate::define_enum_scan!(@tag_expr$d,iter);match tag{$($p=>{$($(let$f=$crate::scan_value!((*iter),$($spec)*);)*)?Some($T::$v$({$($f),*})?)}),*_=>None,}}}};($(#[$attr:meta])*$vis:vis enum$T:ident:raw{$($body:tt)*})=>{$crate::define_enum_scan!{@variant([$(#[$attr])*]$vis$T raw)[]$($body)*}};($(#[$attr:meta])*$vis:vis enum$T:ident:$d:ty{$($body:tt)*})=>{$crate::define_enum_scan!{@variant([$(#[$attr])*]$vis$T$d)[]$($body)*}};}#[derive(Debug,Copy,Clone)]pub enum Usize1{}impl Scan for Usize1{type Output=usize;fn scan<I:ScanSource>(iter:&mut I)->Option<Self::Output>{<usize as Scan>::scan(iter)?.checked_sub(1)}}#[derive(Debug,Copy,Clone)]pub struct CharWithBase(pub char);impl MarkedScan for CharWithBase{type Output=usize;fn mscan<I:ScanSource>(self,iter:&mut I)->Option<Self::Output>{Some((<char as Scan>::scan(iter)?as u8-self.0 as u8)as usize)}}#[derive(Debug,Copy,Clone)]pub enum Chars{}impl Scan for Chars{type Output=Vec<char>;fn scan<I:ScanSource>(iter:&mut I)->Option<Self::Output>{Some(iter.next_token()?.chars().collect())}}#[derive(Debug,Copy,Clone)]pub struct CharsWithBase(pub char);impl MarkedScan for CharsWithBase{type Output=Vec<usize>;fn mscan<I:ScanSource>(self,iter:&mut I)->Option<Self::Output>{Some(iter.next_token()?.chars().map(|c|(c as u8-self.0 as u8)as usize).collect())}}#[derive(Debug,Copy,Clone)]pub enum Byte1{}impl Scan for Byte1{type Output=u8;fn scan<I:ScanSource>(iter:&mut I)->Option<Self::Output>{let bytes=iter.next_token()?.as_bytes();assert_eq!(bytes.len(),1);Some(bytes[0])}}#[derive(Debug,Copy,Clone)]pub struct ByteWithBase(pub u8);impl MarkedScan for ByteWithBase{type Output=usize;fn mscan<I:ScanSource>(self,iter:&mut I)->Option<Self::Output>{Some((<char as Scan>::scan(iter)?as u8-self.0)as usize)}}#[derive(Debug,Copy,Clone)]pub enum Bytes{}impl Scan for Bytes{type Output=Vec<u8>;fn scan<I:ScanSource>(iter:&mut I)->Option<Self::Output>{Some(iter.next_token()?.bytes().collect())}}#[derive(Debug,Copy,Clone)]pub struct BytesWithBase(pub u8);impl MarkedScan for BytesWithBase{type Output=Vec<usize>;fn mscan<I:ScanSource>(self,iter:&mut I)->Option<Self::Output>{Some(iter.next_token()?.bytes().map(|c|(c-self.0)as usize).collect())}}#[derive(Debug,Copy,Clone)]pub struct Collect<T,B=Vec<<T as Scan>::Output>>where T:Scan,B:FromIterator<<T as Scan>::Output>{size:usize,_marker:PhantomData<fn()->(T,B)>}impl<T,B>Collect<T,B>where T:Scan,B:FromIterator<<T as Scan>::Output>{pub fn new(size:usize)->Self{Self{size,_marker:PhantomData}}}impl<T,B>MarkedScan for Collect<T,B>where T:Scan,B:FromIterator<<T as Scan>::Output>{type Output=B;fn mscan<I:ScanSource>(self,iter:&mut I)->Option<Self::Output>{if self.size==0{iter.skip_whitespace();}repeat_with(| |<T as Scan>::scan(iter)).take(self.size).collect()}}#[derive(Debug,Copy,Clone)]pub struct SizedCollect<T,B=Vec<<T as Scan>::Output>>where T:Scan,B:FromIterator<<T as Scan>::Output>{_marker:PhantomData<fn()->(T,B)>}impl<T,B>Scan for SizedCollect<T,B>where T:Scan,B:FromIterator<<T as Scan>::Output>{type Output=B;fn scan<I:ScanSource>(iter:&mut I)->Option<Self::Output>{let size=usize::scan(iter)?;if size==0{iter.skip_whitespace();}repeat_with(| |<T as Scan>::scan(iter)).take(size).collect()}}#[derive(Debug,Copy,Clone)]pub struct Splitted<T,P>where T:Scan{pat:P,_marker:PhantomData<fn()->T>}impl<T,P>Splitted<T,P>where T:Scan{pub fn new(pat:P)->Self{Self{pat,_marker:PhantomData}}}impl<T>MarkedScan for Splitted<T,char>where T:Scan{type Output=Vec<<T as Scan>::Output>;fn mscan<I:ScanSource>(self,iter:&mut I)->Option<Self::Output>{let mut iter=Scanner::new_from_iter(iter.next_token()?.split(self.pat));Some(from_fn(| |<T as Scan>::scan(&mut iter)).collect())}}impl<T>MarkedScan for Splitted<T,&str>where T:Scan{type Output=Vec<<T as Scan>::Output>;fn mscan<I:ScanSource>(self,iter:&mut I)->Option<Self::Output>{let mut iter=Scanner::new_from_iter(iter.next_token()?.split(self.pat));Some(from_fn(| |<T as Scan>::scan(&mut iter)).collect())}}impl<T,F>MarkedScan for F where F:Fn(&str)->Option<T>{type Output=T;fn mscan<I:ScanSource>(self,iter:&mut I)->Option<Self::Output>{self(iter.next_token()?)}}}