pub use __cargo_equip::prelude::*; use fixedbitset::FixedBitSet; #[allow(unused_imports)] use proconio::input; #[allow(unused_imports)] use proconio::marker::*; #[allow(unused_imports)] use std::cmp::{max, min}; #[allow(unused_imports)] use std::collections::btree_map::Entry::{Occupied, Vacant}; #[allow(unused_imports)] use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque}; #[allow(unused_imports)] use std::mem::swap; #[allow(unused_imports)] use std::ops::Bound::{Excluded, Included, Unbounded}; pub fn eratosthenes(n: usize) -> FixedBitSet { let mut ret = FixedBitSet::with_capacity(n + 1); ret.toggle_range(..); ret.set(0, false); ret.set(1, false); for i in (2..).take_while(|&i| i * i <= n) { if ret.contains(i) { let mut j = i * 2; while j <= n { ret.set(j, false); j += i; } } } ret } const DIJ: [(i64, i64); 4] = [(-1, 0), (0, 1), (1, 0), (0, -1)]; #[allow(dead_code)] fn neighbor(n: usize, m: usize, i: usize, j: usize) -> impl Iterator { DIJ.iter() .map(move |&(di, dj)| (i as i64 + di, j as i64 + dj)) .filter(move |&(ni, nj)| 0 <= ni && ni < n as i64 && 0 <= nj && nj < m as i64) .map(|(i, j)| (i as usize, j as usize)) } #[cfg(debug_assertions)] #[allow(unused_macros)] macro_rules! debug { ($x: expr) => { eprintln!("[{}:{}] {}: {:?}", file!(), line!(), stringify!($x), $x) }; } #[cfg(not(debug_assertions))] macro_rules! debug { ($x: expr) => {}; } fn iter_str(iter: T) -> String where T: Iterator, T::Item: ToString, { iter.map(|x| x.to_string()).collect::>().join(" ") } fn main() { use std::io::Write; let stdout = std::io::stdout(); let mut stdout = std::io::BufWriter::new(stdout.lock()); #[allow(unused_macros)] macro_rules! print { ($($arg:tt)*) => (write!(stdout, $($arg)*).unwrap()); } #[allow(unused_macros)] macro_rules! println { () => (writeln!(stdout).unwrap()); ($($arg:tt)*) => (writeln!(stdout, $($arg)*).unwrap()); } input! { n: usize } let is_p = eratosthenes(3 * n); let mut sbs2 = vec![0; 2 * n + 1]; let mut ans = 0_i64; let primes: Vec<_> = is_p.ones().collect(); debug!(&primes); let ni = primes.partition_point(|&x| x <= n); debug!(ni); let mut ci = ni - 1; for (bi, b) in (primes[0..ni].iter().copied().enumerate()).rev() { while b < primes[ci] { let c = primes[ci]; let up = primes.partition_point(|&x| x <= 2 * n + c); for &d in &primes[(ci + 1)..up] { sbs2[d - c] += 1; } ci -= 1; } for &a in &primes[..bi] { ans += sbs2[a + b]; } } println!("{}", ans); stdout.flush().unwrap(); } // The following code was expanded by `cargo-equip`. /// # Bundled libraries /// /// - `fixedbitset 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)` licensed under `MIT/Apache-2.0` as `crate::__cargo_equip::crates::fixedbitset` /// - `lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)` licensed under `MIT/Apache-2.0` as `crate::__cargo_equip::crates::__lazy_static_1_4_0` /// - `proconio 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)` licensed under `MIT OR Apache-2.0` as `crate::__cargo_equip::crates::proconio` /// /// # License and Copyright Notices /// /// - `fixedbitset 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)` /// /// ```text /// Copyright (c) 2015-2017 /// /// Permission is hereby granted, free of charge, to any /// person obtaining a copy of this software and associated /// documentation files (the "Software"), to deal in the /// Software without restriction, including without /// limitation the rights to use, copy, modify, merge, /// publish, distribute, sublicense, and/or sell copies of /// the Software, and to permit persons to whom the Software /// is furnished to do so, subject to the following /// conditions: /// /// The above copyright notice and this permission notice /// shall be included in all copies or substantial portions /// of the Software. /// /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF /// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED /// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A /// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT /// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY /// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION /// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR /// IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER /// DEALINGS IN THE SOFTWARE. /// ``` /// /// - `lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)` /// /// ```text /// Copyright (c) 2010 The Rust Project Developers /// /// Permission is hereby granted, free of charge, to any /// person obtaining a copy of this software and associated /// documentation files (the "Software"), to deal in the /// Software without restriction, including without /// limitation the rights to use, copy, modify, merge, /// publish, distribute, sublicense, and/or sell copies of /// the Software, and to permit persons to whom the Software /// is furnished to do so, subject to the following /// conditions: /// /// The above copyright notice and this permission notice /// shall be included in all copies or substantial portions /// of the Software. /// /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF /// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED /// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A /// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT /// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY /// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION /// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR /// IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER /// DEALINGS IN THE SOFTWARE. /// ``` /// /// - `proconio 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)` /// /// ```text /// The MIT License /// Copyright 2019 (C) statiolake /// /// Permission is hereby granted, free of charge, to any person obtaining a copy of /// this software and associated documentation files (the "Software"), to deal in /// the Software without restriction, including without limitation the rights to /// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of /// the Software, and to permit persons to whom the Software is furnished to do so, /// subject to the following conditions: /// /// The above copyright notice and this permission notice shall be included in all /// copies or substantial portions of the Software. /// /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS /// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR /// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER /// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN /// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. /// /// Copyright for original `input!` macro is held by Hideyuki Tanaka, 2019. The /// original macro is licensed under BSD 3-clause license. /// /// Redistribution and use in source and binary forms, with or without /// modification, are permitted provided that the following conditions are met: /// /// 1. Redistributions of source code must retain the above copyright notice, this /// list of conditions and the following disclaimer. /// /// 2. Redistributions in binary form must reproduce the above copyright notice, /// this list of conditions and the following disclaimer in the documentation /// and/or other materials provided with the distribution. /// /// 3. Neither the name of the copyright holder nor the names of its contributors /// may be used to endorse or promote products derived from this software /// without specific prior written permission. /// /// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND /// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED /// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE /// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE /// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL /// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR /// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER /// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, /// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE /// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. /// ``` #[cfg_attr(any(), rustfmt::skip)] #[allow(unused)] mod __cargo_equip { pub(crate) mod crates { pub mod fixedbitset {#![cfg_attr(not(feature="std"),no_std)]mod range{use std::ops::{RangeFull,RangeFrom,RangeTo,Range,};pub trait IndexRange{#[inline]fn start(&self)->Option{None}#[inline]fn end(&self)->Option{None}}implIndexRangefor RangeFull{}implIndexRangefor RangeFrom{#[inline]fn start(&self)->Option{Some(self.start)}}implIndexRangefor RangeTo{#[inline]fn end(&self)->Option{Some(self.end)}}implIndexRangefor Range{#[inline]fn start(&self)->Option{Some(self.start)}#[inline]fn end(&self)->Option{Some(self.end)}}}use std::fmt::Write;use std::fmt::{Binary,Display,Error,Formatter};pub use range::IndexRange;use std::cmp::{Ord,Ordering};use std::iter::{Chain,FromIterator};use std::ops::{BitAnd,BitAndAssign,BitOr,BitOrAssign,BitXor,BitXorAssign,Index};const BITS:usize=32;type Block=u32;#[inline]fn div_rem(x:usize,d:usize)->(usize,usize){(x/d,x%d)}#[derive(Debug,PartialEq,Eq,PartialOrd,Ord,Hash,Default)]#[cfg_attr(feature="serde",derive(Serialize,Deserialize))]pub struct FixedBitSet{data:Vec,length:usize,}impl FixedBitSet{pub const fn new()->Self{FixedBitSet{data:Vec::new(),length:0,}}pub fn with_capacity(bits:usize)->Self{let(mut blocks,rem)=div_rem(bits,BITS);blocks+=(rem>0)as usize;FixedBitSet{data:vec![0;blocks],length:bits,}}pub fn with_capacity_and_blocks>(bits:usize,blocks:I)->Self{let(mut n_blocks,rem)=div_rem(bits,BITS);n_blocks+=(rem>0)as usize;let mut data:Vec =blocks.into_iter().collect();if data.len()!=n_blocks{data.resize(n_blocks,0);}let end=data.len()*32;for(block,mask)in Masks::new(bits..end,end){unsafe{*data.get_unchecked_mut(block)&=!mask;}}FixedBitSet{data,length:bits}}pub fn grow(&mut self,bits:usize){let(mut blocks,rem)=div_rem(bits,BITS);blocks+=(rem>0)as usize;if bits>self.length{self.length=bits;self.data.resize(blocks,0);}}#[inline]pub fn len(&self)->usize{self.length}#[inline]pub fn is_empty(&self)->bool{self.len()==0}#[inline]pub fn contains(&self,bit:usize)->bool{let(block,i)=div_rem(bit,BITS);match self.data.get(block){None=>false,Some(b)=>(b&(1<bool{assert!(bit(&self,range:T)->usize{Masks::new(range,self.length).map(|(block,mask)|unsafe{let value=*self.data.get_unchecked(block);(value&mask).count_ones()as usize}).sum()}#[inline]pub fn set_range(&mut self,range:T,enabled:bool){for(block,mask)in Masks::new(range,self.length){unsafe{if enabled{*self.data.get_unchecked_mut(block)|=mask;}else{*self.data.get_unchecked_mut(block)&=!mask;}}}}#[inline]pub fn insert_range(&mut self,range:T){self.set_range(range,true);}#[inline]pub fn toggle_range(&mut self,range:T){for(block,mask)in Masks::new(range,self.length){unsafe{*self.data.get_unchecked_mut(block)^=mask;}}}#[inline]pub fn as_slice(&self)->&[u32]{&self.data}#[inline]pub fn as_mut_slice(&mut self)->&mut[u32]{&mut self.data}#[inline]pub fn ones(&self)->Ones{match self.as_slice().split_first(){Some((&block,rem))=>Ones{bitset:block,block_idx:0,remaining_blocks:rem,},None=>Ones{bitset:0,block_idx:0,remaining_blocks:&[],},}}pub fn intersection<'a>(&'a self,other:&'a FixedBitSet)->Intersection<'a>{Intersection{iter:self.ones(),other,}}pub fn union<'a>(&'a self,other:&'a FixedBitSet)->Union<'a>{Union{iter:self.ones().chain(other.difference(self)),}}pub fn difference<'a>(&'a self,other:&'a FixedBitSet)->Difference<'a>{Difference{iter:self.ones(),other,}}pub fn symmetric_difference<'a>(&'a self,other:&'a FixedBitSet)->SymmetricDifference<'a>{SymmetricDifference{iter:self.difference(other).chain(other.difference(self)),}}pub fn union_with(&mut self,other:&FixedBitSet){if other.len()>=self.len(){self.grow(other.len());}for(x,y)in self.data.iter_mut().zip(other.data.iter()){*x|=*y;}}pub fn intersect_with(&mut self,other:&FixedBitSet){for(x,y)in self.data.iter_mut().zip(other.data.iter()){*x&=*y;}let mn=std::cmp::min(self.data.len(),other.data.len());for wd in&mut self.data[mn..]{*wd=0;}}pub fn difference_with(&mut self,other:&FixedBitSet){for(x,y)in self.data.iter_mut().zip(other.data.iter()){*x&=!*y;}}pub fn symmetric_difference_with(&mut self,other:&FixedBitSet){if other.len()>=self.len(){self.grow(other.len());}for(x,y)in self.data.iter_mut().zip(other.data.iter()){*x^=*y;}}pub fn is_disjoint(&self,other:&FixedBitSet)->bool{self.data.iter().zip(other.data.iter()).all(|(x,y)|x&y==0)}pub fn is_subset(&self,other:&FixedBitSet)->bool{self.data.iter().zip(other.data.iter()).all(|(x,y)|x&!y==0)&&self.data.iter().skip(other.data.len()).all(|x|*x==0)}pub fn is_superset(&self,other:&FixedBitSet)->bool{other.is_subset(self)}}impl Binary for FixedBitSet{fn fmt(&self,f:&mut Formatter<'_>)->Result<(),Error>{if f.alternate(){f.write_str("0b")?;}for i in 0..self.length{if self[i]{f.write_char('1')?;}else{f.write_char('0')?;}}Ok(())}}impl Display for FixedBitSet{fn fmt(&self,f:&mut Formatter<'_>)->Result<(),Error>{Binary::fmt(&self,f)}}pub struct Difference<'a>{iter:Ones<'a>,other:&'a FixedBitSet,}impl<'a>Iterator for Difference<'a>{type Item=usize;#[inline]fn next(&mut self)->Option{while let Some(nxt)=self.iter.next(){if!self.other.contains(nxt){return Some(nxt);}}None}}pub struct SymmetricDifference<'a>{iter:Chain,Difference<'a>>,}impl<'a>Iterator for SymmetricDifference<'a>{type Item=usize;#[inline]fn next(&mut self)->Option{self.iter.next()}}pub struct Intersection<'a>{iter:Ones<'a>,other:&'a FixedBitSet,}impl<'a>Iterator for Intersection<'a>{type Item=usize;#[inline]fn next(&mut self)->Option{while let Some(nxt)=self.iter.next(){if self.other.contains(nxt){return Some(nxt);}}None}}pub struct Union<'a>{iter:Chain,Difference<'a>>,}impl<'a>Iterator for Union<'a>{type Item=usize;#[inline]fn next(&mut self)->Option{self.iter.next()}}struct Masks{first_block:usize,first_mask:Block,last_block:usize,last_mask:Block,}impl Masks{#[inline]fn new(range:T,length:usize)->Masks{let start=range.start().unwrap_or(0);let end=range.end().unwrap_or(length);assert!(start<=end&&end<=length,"invalid range {}..{} for a fixedbitset of size {}",start,end,length);let(first_block,first_rem)=div_rem(start,BITS);let(last_block,last_rem)=div_rem(end,BITS);Masks{first_block:first_block as usize,first_mask:Block::max_value()<>1)>>(BITS-last_rem-1),}}}impl Iterator for Masks{type Item=(usize,Block);#[inline]fn next(&mut self)->Option{match self.first_block.cmp(&self.last_block){Ordering::Less=>{let res=(self.first_block,self.first_mask);self.first_block+=1;self.first_mask=!0;Some(res)}Ordering::Equal=>{let mask=self.first_mask&self.last_mask;let res=if mask==0{None}else{Some((self.first_block,mask))};self.first_block+=1;res}Ordering::Greater=>None,}}}pub struct Ones<'a>{bitset:Block,block_idx:usize,remaining_blocks:&'a[Block],}impl<'a>Iterator for Ones<'a>{type Item=usize;#[inline]fn next(&mut self)->Option{while self.bitset==0{if self.remaining_blocks.is_empty(){return None;}self.bitset=self.remaining_blocks[0];self.remaining_blocks=&self.remaining_blocks[1..];self.block_idx+=1;}let t=self.bitset&(0 as Block).wrapping_sub(self.bitset);let r=self.bitset.trailing_zeros()as usize;self.bitset^=t;Some(self.block_idx*BITS+r)}}impl Clone for FixedBitSet{#[inline]fn clone(&self)->Self{FixedBitSet{data:self.data.clone(),length:self.length,}}}impl Indexfor FixedBitSet{type Output=bool;#[inline]fn index(&self,bit:usize)->&bool{if self.contains(bit){&true}else{&false}}}impl Extendfor FixedBitSet{fn extend>(&mut self,src:I){let iter=src.into_iter();for i in iter{if i>=self.len(){self.grow(i+1);}self.put(i);}}}impl FromIteratorfor FixedBitSet{fn from_iter>(src:I)->Self{let mut fbs=FixedBitSet::with_capacity(0);fbs.extend(src);fbs}}impl<'a>BitAnd for&'a FixedBitSet{type Output=FixedBitSet;fn bitand(self,other:&FixedBitSet)->FixedBitSet{let(short,long)={if self.len()<=other.len(){(&self.data,&other.data)}else{(&other.data,&self.data)}};let mut data=short.clone();for(data,block)in data.iter_mut().zip(long.iter()){*data&=*block;}let len=std::cmp::min(self.len(),other.len());FixedBitSet{data,length:len}}}impl<'a>BitAndAssign for FixedBitSet{fn bitand_assign(&mut self,other:Self){self.intersect_with(&other);}}impl<'a>BitAndAssign<&Self>for FixedBitSet{fn bitand_assign(&mut self,other:&Self){self.intersect_with(other);}}impl<'a>BitOr for&'a FixedBitSet{type Output=FixedBitSet;fn bitor(self,other:&FixedBitSet)->FixedBitSet{let(short,long)={if self.len()<=other.len(){(&self.data,&other.data)}else{(&other.data,&self.data)}};let mut data=long.clone();for(data,block)in data.iter_mut().zip(short.iter()){*data|=*block;}let len=std::cmp::max(self.len(),other.len());FixedBitSet{data,length:len}}}impl<'a>BitOrAssign for FixedBitSet{fn bitor_assign(&mut self,other:Self){self.union_with(&other);}}impl<'a>BitOrAssign<&Self>for FixedBitSet{fn bitor_assign(&mut self,other:&Self){self.union_with(other);}}impl<'a>BitXor for&'a FixedBitSet{type Output=FixedBitSet;fn bitxor(self,other:&FixedBitSet)->FixedBitSet{let(short,long)={if self.len()<=other.len(){(&self.data,&other.data)}else{(&other.data,&self.data)}};let mut data=long.clone();for(data,block)in data.iter_mut().zip(short.iter()){*data^=*block;}let len=std::cmp::max(self.len(),other.len());FixedBitSet{data,length:len}}}impl<'a>BitXorAssign for FixedBitSet{fn bitxor_assign(&mut self,other:Self){self.symmetric_difference_with(&other);}}impl<'a>BitXorAssign<&Self>for FixedBitSet{fn bitxor_assign(&mut self,other:&Self){self.symmetric_difference_with(other);}}#[test]fn it_works(){const N:usize=50;let mut fb=FixedBitSet::with_capacity(N);for i in 0..(N+10){assert_eq!(fb.contains(i),false);}fb.insert(10);fb.set(11,false);fb.set(12,false);fb.set(12,true);fb.set(N-1,true);assert!(fb.contains(10));assert!(!fb.contains(11));assert!(fb.contains(12));assert!(fb.contains(N-1));for i in 0..N{let contain=i==10||i==12||i==N-1;assert_eq!(contain,fb[i]);}fb.clear();}#[test]fn with_blocks(){let fb=FixedBitSet::with_capacity_and_blocks(50,vec![8u32,0u32]);assert!(fb.contains(3));let ones:Vec<_> =fb.ones().collect();assert_eq!(ones.len(),1);}#[test]fn with_blocks_too_small(){let mut fb=FixedBitSet::with_capacity_and_blocks(500,vec![8u32,0u32]);fb.insert(400);assert!(fb.contains(400));}#[test]fn with_blocks_too_big(){let fb=FixedBitSet::with_capacity_and_blocks(1,vec![8u32]);assert!(!fb.contains(3));}#[test]fn with_blocks_too_big_range_check(){let fb=FixedBitSet::with_capacity_and_blocks(1,vec![0xff]);assert!(fb.contains(0));for i in 1..0xff{assert!(!fb.contains(i));}}#[test]fn grow(){let mut fb=FixedBitSet::with_capacity(48);for i in 0..fb.len(){fb.set(i,true);}let old_len=fb.len();fb.grow(72);for j in 0..fb.len(){assert_eq!(fb.contains(j),j =fb.ones().collect();assert_eq!(vec![7,11,12,35,40,50,77,95,99],ones);}#[test]fn iter_ones_range(){fn test_range(from:usize,to:usize,capa:usize){assert!(to<=capa);let mut fb=FixedBitSet::with_capacity(capa);for i in from..to{fb.insert(i);}let ones:Vec<_> =fb.ones().collect();let expected:Vec<_> =(from..to).collect();assert_eq!(expected,ones);}for i in 0..100{test_range(i,100,100);test_range(0,i,100);}}#[should_panic]#[test]fn count_ones_oob(){let fb=FixedBitSet::with_capacity(100);fb.count_ones(90..101);}#[should_panic]#[test]fn count_ones_negative_range(){let fb=FixedBitSet::with_capacity(100);fb.count_ones(90..80);}#[test]fn count_ones_panic(){for i in 1..128{let fb=FixedBitSet::with_capacity(i);for j in 0..fb.len()+1{for k in j..fb.len()+1{assert_eq!(fb.count_ones(j..k),0);}}}}#[test]fn default(){let fb=FixedBitSet::default();assert_eq!(fb.len(),0);}#[test]fn insert_range(){let mut fb=FixedBitSet::with_capacity(97);fb.insert_range(..3);fb.insert_range(9..32);fb.insert_range(37..81);fb.insert_range(90..);for i in 0..97{assert_eq!(fb.contains(i),i<3||9<=i&&i<32||37<=i&&i<81||90<=i);}assert!(!fb.contains(97));assert!(!fb.contains(127));assert!(!fb.contains(128));}#[test]fn set_range(){let mut fb=FixedBitSet::with_capacity(48);fb.insert_range(..);fb.set_range(..32,false);fb.set_range(37..,false);fb.set_range(5..9,true);fb.set_range(40..40,true);for i in 0..48{assert_eq!(fb.contains(i),5<=i&&i<9||32<=i&&i<37);}assert!(!fb.contains(48));assert!(!fb.contains(64));}#[test]fn toggle_range(){let mut fb=FixedBitSet::with_capacity(40);fb.insert_range(..10);fb.insert_range(34..38);fb.toggle_range(5..12);fb.toggle_range(30..);for i in 0..40{assert_eq!(fb.contains(i),i<5||10<=i&&i<12||30<=i&&i<34||38<=i);}assert!(!fb.contains(40));assert!(!fb.contains(64));}#[test]fn bitand_equal_lengths(){let len=109;let a_end=59;let b_start=23;let mut a=FixedBitSet::with_capacity(len);let mut b=FixedBitSet::with_capacity(len);a.set_range(..a_end,true);b.set_range(b_start..,true);let ab=&a& &b;for i in 0..b_start{assert!(!ab.contains(i));}for i in b_start..a_end{assert!(ab.contains(i));}for i in a_end..len{assert!(!ab.contains(i));}assert_eq!(a.len(),ab.len());}#[test]fn bitand_first_smaller(){let a_len=113;let b_len=137;let len=std::cmp::min(a_len,b_len);let a_end=97;let b_start=89;let mut a=FixedBitSet::with_capacity(a_len);let mut b=FixedBitSet::with_capacity(b_len);a.set_range(..a_end,true);b.set_range(b_start..,true);let ab=&a& &b;for i in 0..b_start{assert!(!ab.contains(i));}for i in b_start..a_end{assert!(ab.contains(i));}for i in a_end..len{assert!(!ab.contains(i));}assert_eq!(a.len(),ab.len());}#[test]fn bitand_first_larger(){let a_len=173;let b_len=137;let len=std::cmp::min(a_len,b_len);let a_end=107;let b_start=43;let mut a=FixedBitSet::with_capacity(a_len);let mut b=FixedBitSet::with_capacity(b_len);a.set_range(..a_end,true);b.set_range(b_start..,true);let ab=&a& &b;for i in 0..b_start{assert!(!ab.contains(i));}for i in b_start..a_end{assert!(ab.contains(i));}for i in a_end..len{assert!(!ab.contains(i));}assert_eq!(b.len(),ab.len());}#[test]fn intersection(){let len=109;let a_end=59;let b_start=23;let mut a=FixedBitSet::with_capacity(len);let mut b=FixedBitSet::with_capacity(len);a.set_range(..a_end,true);b.set_range(b_start..,true);let mut ab=a.intersection(&b).collect::();for i in 0..b_start{assert!(!ab.contains(i));}for i in b_start..a_end{assert!(ab.contains(i));}for i in a_end..len{assert!(!ab.contains(i));}a.intersect_with(&b);ab.grow(a.len());assert_eq!(ab,a,"intersection and intersect_with produce the same results");}#[test]fn union(){let a_len=173;let b_len=137;let a_start=139;let b_end=107;let mut a=FixedBitSet::with_capacity(a_len);let mut b=FixedBitSet::with_capacity(b_len);a.set_range(a_start..,true);b.set_range(..b_end,true);let ab=a.union(&b).collect::();for i in a_start..a_len{assert!(ab.contains(i));}for i in 0..b_end{assert!(ab.contains(i));}for i in b_end..a_start{assert!(!ab.contains(i));}a.union_with(&b);assert_eq!(ab,a,"union and union_with produce the same results");}#[test]fn difference(){let a_len=83;let b_len=151;let a_start=0;let a_end=79;let b_start=53;let mut a=FixedBitSet::with_capacity(a_len);let mut b=FixedBitSet::with_capacity(b_len);a.set_range(a_start..a_end,true);b.set_range(b_start..b_len,true);let mut a_diff_b=a.difference(&b).collect::();for i in a_start..b_start{assert!(a_diff_b.contains(i));}for i in b_start..b_len{assert!(!a_diff_b.contains(i));}a.difference_with(&b);a_diff_b.grow(a.len());assert_eq!(a_diff_b,a,"difference and difference_with produce the same results");}#[test]fn symmetric_difference(){let a_len=83;let b_len=151;let a_start=47;let a_end=79;let b_start=53;let mut a=FixedBitSet::with_capacity(a_len);let mut b=FixedBitSet::with_capacity(b_len);a.set_range(a_start..a_end,true);b.set_range(b_start..b_len,true);let a_sym_diff_b=a.symmetric_difference(&b).collect::();for i in 0..a_start{assert!(!a_sym_diff_b.contains(i));}for i in a_start..b_start{assert!(a_sym_diff_b.contains(i));}for i in b_start..a_end{assert!(!a_sym_diff_b.contains(i));}for i in a_end..b_len{assert!(a_sym_diff_b.contains(i));}a.symmetric_difference_with(&b);assert_eq!(a_sym_diff_b,a,"symmetric_difference and _with produce the same results");}#[test]fn bitor_equal_lengths(){let len=109;let a_start=17;let a_end=23;let b_start=19;let b_end=59;let mut a=FixedBitSet::with_capacity(len);let mut b=FixedBitSet::with_capacity(len);a.set_range(a_start..a_end,true);b.set_range(b_start..b_end,true);let ab=&a|&b;for i in 0..a_start{assert!(!ab.contains(i));}for i in a_start..b_end{assert!(ab.contains(i));}for i in b_end..len{assert!(!ab.contains(i));}assert_eq!(ab.len(),len);}#[test]fn bitor_first_smaller(){let a_len=113;let b_len=137;let a_end=89;let b_start=97;let mut a=FixedBitSet::with_capacity(a_len);let mut b=FixedBitSet::with_capacity(b_len);a.set_range(..a_end,true);b.set_range(b_start..,true);let ab=&a|&b;for i in 0..a_end{assert!(ab.contains(i));}for i in a_end..b_start{assert!(!ab.contains(i));}for i in b_start..b_len{assert!(ab.contains(i));}assert_eq!(b_len,ab.len());}#[test]fn bitor_first_larger(){let a_len=173;let b_len=137;let a_start=139;let b_end=107;let mut a=FixedBitSet::with_capacity(a_len);let mut b=FixedBitSet::with_capacity(b_len);a.set_range(a_start..,true);b.set_range(..b_end,true);let ab=&a|&b;for i in a_start..a_len{assert!(ab.contains(i));}for i in 0..b_end{assert!(ab.contains(i));}for i in b_end..a_start{assert!(!ab.contains(i));}assert_eq!(a_len,ab.len());}#[test]fn bitxor_equal_lengths(){let len=109;let a_end=59;let b_start=23;let mut a=FixedBitSet::with_capacity(len);let mut b=FixedBitSet::with_capacity(len);a.set_range(..a_end,true);b.set_range(b_start..,true);let ab=&a^&b;for i in 0..b_start{assert!(ab.contains(i));}for i in b_start..a_end{assert!(!ab.contains(i));}for i in a_end..len{assert!(ab.contains(i));}assert_eq!(a.len(),ab.len());}#[test]fn bitxor_first_smaller(){let a_len=113;let b_len=137;let len=std::cmp::max(a_len,b_len);let a_end=97;let b_start=89;let mut a=FixedBitSet::with_capacity(a_len);let mut b=FixedBitSet::with_capacity(b_len);a.set_range(..a_end,true);b.set_range(b_start..,true);let ab=&a^&b;for i in 0..b_start{assert!(ab.contains(i));}for i in b_start..a_end{assert!(!ab.contains(i));}for i in a_end..len{assert!(ab.contains(i));}assert_eq!(b.len(),ab.len());}#[test]fn bitxor_first_larger(){let a_len=173;let b_len=137;let len=std::cmp::max(a_len,b_len);let a_end=107;let b_start=43;let mut a=FixedBitSet::with_capacity(a_len);let mut b=FixedBitSet::with_capacity(b_len);a.set_range(..a_end,true);b.set_range(b_start..,true);let ab=&a^&b;for i in 0..b_start{assert!(ab.contains(i));}for i in b_start..a_end{assert!(!ab.contains(i));}for i in a_end..b_len{assert!(ab.contains(i));}for i in b_len..len{assert!(!ab.contains(i));}assert_eq!(a.len(),ab.len());}#[test]fn bitand_assign_shorter(){let a_ones:Vec =vec![2,3,7,19,31,32,37,41,43,47,71,73,101];let b_ones:Vec =vec![2,7,8,11,23,31,32];let a_and_b:Vec =vec![2,7,31,32];let mut a=a_ones.iter().cloned().collect::();let b=b_ones.iter().cloned().collect::();a&=b;let res=a.ones().collect::>();assert!(res==a_and_b);}#[test]fn bitand_assign_longer(){let a_ones:Vec =vec![2,7,8,11,23,31,32];let b_ones:Vec =vec![2,3,7,19,31,32,37,41,43,47,71,73,101];let a_and_b:Vec =vec![2,7,31,32];let mut a=a_ones.iter().cloned().collect::();let b=b_ones.iter().cloned().collect::();a&=b;let res=a.ones().collect::>();assert!(res==a_and_b);}#[test]fn bitor_assign_shorter(){let a_ones:Vec =vec![2,3,7,19,31,32,37,41,43,47,71,73,101];let b_ones:Vec =vec![2,7,8,11,23,31,32];let a_or_b:Vec =vec![2,3,7,8,11,19,23,31,32,37,41,43,47,71,73,101];let mut a=a_ones.iter().cloned().collect::();let b=b_ones.iter().cloned().collect::();a|=b;let res=a.ones().collect::>();assert!(res==a_or_b);}#[test]fn bitor_assign_longer(){let a_ones:Vec =vec![2,7,8,11,23,31,32];let b_ones:Vec =vec![2,3,7,19,31,32,37,41,43,47,71,73,101];let a_or_b:Vec =vec![2,3,7,8,11,19,23,31,32,37,41,43,47,71,73,101];let mut a=a_ones.iter().cloned().collect::();let b=b_ones.iter().cloned().collect::();a|=b;let res=a.ones().collect::>();assert!(res==a_or_b);}#[test]fn bitxor_assign_shorter(){let a_ones:Vec =vec![2,3,7,19,31,32,37,41,43,47,71,73,101];let b_ones:Vec =vec![2,7,8,11,23,31,32];let a_xor_b:Vec =vec![3,8,11,19,23,37,41,43,47,71,73,101];let mut a=a_ones.iter().cloned().collect::();let b=b_ones.iter().cloned().collect::();a^=b;let res=a.ones().collect::>();assert!(res==a_xor_b);}#[test]fn bitxor_assign_longer(){let a_ones:Vec =vec![2,7,8,11,23,31,32];let b_ones:Vec =vec![2,3,7,19,31,32,37,41,43,47,71,73,101];let a_xor_b:Vec =vec![3,8,11,19,23,37,41,43,47,71,73,101];let mut a=a_ones.iter().cloned().collect::();let b=b_ones.iter().cloned().collect::();a^=b;let res=a.ones().collect::>();assert!(res==a_xor_b);}#[test]fn op_assign_ref(){let mut a=FixedBitSet::with_capacity(8);let b=FixedBitSet::with_capacity(8);a&=&b;a|=&b;a^=&b;}#[test]fn subset_superset_shorter(){let a_ones:Vec =vec![7,31,32,63];let b_ones:Vec =vec![2,7,19,31,32,37,41,43,47,63,73,101];let mut a=a_ones.iter().cloned().collect::();let b=b_ones.iter().cloned().collect::();assert!(a.is_subset(&b)&&b.is_superset(&a));a.insert(14);assert!(!a.is_subset(&b)&&!b.is_superset(&a));}#[test]fn subset_superset_longer(){let a_len=153;let b_len=75;let a_ones:Vec =vec![7,31,32,63];let b_ones:Vec =vec![2,7,19,31,32,37,41,43,47,63,73];let mut a=FixedBitSet::with_capacity(a_len);let mut b=FixedBitSet::with_capacity(b_len);a.extend(a_ones.iter().cloned());b.extend(b_ones.iter().cloned());assert!(a.is_subset(&b)&&b.is_superset(&a));a.insert(100);assert!(!a.is_subset(&b)&&!b.is_superset(&a));}#[test]fn is_disjoint_first_shorter(){let a_len=75;let b_len=153;let a_ones:Vec =vec![2,19,32,37,41,43,47,73];let b_ones:Vec =vec![7,23,31,63,124];let mut a=FixedBitSet::with_capacity(a_len);let mut b=FixedBitSet::with_capacity(b_len);a.extend(a_ones.iter().cloned());b.extend(b_ones.iter().cloned());assert!(a.is_disjoint(&b));a.insert(63);assert!(!a.is_disjoint(&b));}#[test]fn is_disjoint_first_longer(){let a_ones:Vec =vec![2,19,32,37,41,43,47,73,101];let b_ones:Vec =vec![7,23,31,63];let a=a_ones.iter().cloned().collect::();let mut b=b_ones.iter().cloned().collect::();assert!(a.is_disjoint(&b));b.insert(2);assert!(!a.is_disjoint(&b));}#[test]fn extend_on_empty(){let items:Vec =vec![2,3,5,7,11,13,17,19,23,27,29,31,37,167];let mut fbs=FixedBitSet::with_capacity(0);fbs.extend(items.iter().cloned());let ones=fbs.ones().collect::>();assert!(ones==items);}#[test]fn extend(){let items:Vec =vec![2,3,5,7,11,13,17,19,23,27,29,31,37,167];let mut fbs=FixedBitSet::with_capacity(168);let new:Vec =vec![7,37,67,137];for i in&new{fbs.put(*i);}fbs.extend(items.iter().cloned());let ones=fbs.ones().collect::>();let expected={let mut tmp=items.clone();tmp.extend(new);tmp.sort();tmp.dedup();tmp};assert!(ones==expected);}#[test]fn from_iterator(){let items:Vec =vec![0,2,4,6,8];let fb=items.iter().cloned().collect::();for i in items{assert!(fb.contains(i));}for i in vec![1,3,5,7]{assert!(!fb.contains(i));}assert_eq!(fb.len(),9);}#[test]fn from_iterator_ones(){let len=257;let mut fb=FixedBitSet::with_capacity(len);for i in(0..len).filter(|i|i%7==0){fb.put(i);}fb.put(len-1);let dup=fb.ones().collect::();assert_eq!(fb.len(),dup.len());assert_eq!(fb.ones().collect::>(),dup.ones().collect::>());}#[test]fn binary_trait(){let items:Vec =vec![1,5,7,10,14,15];let fb=items.iter().cloned().collect::();assert_eq!(format!("{:b}",fb),"0100010100100011");assert_eq!(format!("{:#b}",fb),"0b0100010100100011");}#[test]fn display_trait(){let len=8;let mut fb=FixedBitSet::with_capacity(len);fb.put(4);fb.put(2);assert_eq!(format!("{}",fb),"00101000");assert_eq!(format!("{:#}",fb),"0b00101000");}} pub mod __lazy_static_1_4_0 {#![no_std]use crate::__cargo_equip::preludes::__lazy_static_1_4_0::*;pub use crate::__cargo_equip::macros::__lazy_static_1_4_0::*;#[path="inline_lazy.rs"]pub mod lazy{use crate::__cargo_equip::preludes::__lazy_static_1_4_0::*;extern crate core;extern crate std;use self::std::prelude::v1::*;use self::std::cell::Cell;use self::std::hint::unreachable_unchecked;use self::std::sync::Once;#[allow(deprecated)]pub use self::std::sync::ONCE_INIT;pub struct Lazy(Cell>,Once);implLazy{#[allow(deprecated)]pub const INIT:Self=Lazy(Cell::new(None),ONCE_INIT);#[inline(always)]pub fn get(&'static self,f:F)->&T where F:FnOnce()->T,{self.1.call_once(||{self.0.set(Some(f()));});unsafe{match*self.0.as_ptr(){Some(ref x)=>x,None=>{debug_assert!(false,"attempted to derefence an uninitialized lazy static. This is a bug");unreachable_unchecked()},}}}}unsafe implSync for Lazy{}#[macro_export]macro_rules!__cargo_equip_macro_def___lazy_static_1_4_0___lazy_static_create{($NAME:ident,$T:ty)=>{static$NAME:$crate::__cargo_equip::crates::__lazy_static_1_4_0::lazy::Lazy<$T> =$crate::__cargo_equip::crates::__lazy_static_1_4_0::lazy::Lazy::INIT;};}macro_rules!__lazy_static_create{($($tt:tt)*)=>(crate::__cargo_equip_macro_def___lazy_static_1_4_0___lazy_static_create!{$($tt)*})}}pub use core::ops::Deref as __Deref;#[macro_export(local_inner_macros)]macro_rules!__cargo_equip_macro_def___lazy_static_1_4_0___lazy_static_internal{($(#[$attr:meta])*($($vis:tt)*)static ref$N:ident:$T:ty=$e:expr;$($t:tt)*)=>{__lazy_static_internal!(@MAKE TY,$(#[$attr])*,($($vis)*),$N);__lazy_static_internal!(@TAIL,$N:$T=$e);lazy_static!($($t)*);};(@TAIL,$N:ident:$T:ty=$e:expr)=>{impl$crate::__cargo_equip::crates::__lazy_static_1_4_0::__Deref for$N{type Target=$T;fn deref(&self)->&$T{#[inline(always)]fn __static_ref_initialize()->$T{$e}#[inline(always)]fn __stability()->&'static$T{__lazy_static_create!(LAZY,$T);LAZY.get(__static_ref_initialize)}__stability()}}impl$crate::__cargo_equip::crates::__lazy_static_1_4_0::LazyStatic for$N{fn initialize(lazy:&Self){let _=&**lazy;}}};(@MAKE TY,$(#[$attr:meta])*,($($vis:tt)*),$N:ident)=>{#[allow(missing_copy_implementations)]#[allow(non_camel_case_types)]#[allow(dead_code)]$(#[$attr])*$($vis)*struct$N{__private_field:()}#[doc(hidden)]$($vis)*static$N:$N=$N{__private_field:()};};()=>()}macro_rules!__lazy_static_internal{($($tt:tt)*)=>(crate::__cargo_equip_macro_def___lazy_static_1_4_0___lazy_static_internal!{$($tt)*})}#[macro_export(local_inner_macros)]macro_rules!__cargo_equip_macro_def___lazy_static_1_4_0_lazy_static{($(#[$attr:meta])*static ref$N:ident:$T:ty=$e:expr;$($t:tt)*)=>{__lazy_static_internal!($(#[$attr])*()static ref$N:$T=$e;$($t)*);};($(#[$attr:meta])*pub static ref$N:ident:$T:ty=$e:expr;$($t:tt)*)=>{__lazy_static_internal!($(#[$attr])*(pub)static ref$N:$T=$e;$($t)*);};($(#[$attr:meta])*pub($($vis:tt)+)static ref$N:ident:$T:ty=$e:expr;$($t:tt)*)=>{__lazy_static_internal!($(#[$attr])*(pub($($vis)+))static ref$N:$T=$e;$($t)*);};()=>()}macro_rules!lazy_static{($($tt:tt)*)=>(crate::__cargo_equip_macro_def___lazy_static_1_4_0_lazy_static!{$($tt)*})}pub trait LazyStatic{fn initialize(lazy:&Self);}pub fn initialize(lazy:&T){LazyStatic::initialize(lazy);}} pub mod proconio {#![allow(clippy::needless_doctest_main,clippy::print_literal)]use crate::__cargo_equip::preludes::proconio::*;pub use crate::__cargo_equip::macros::proconio::*;pub mod marker{use crate::__cargo_equip::preludes::proconio::*;pub enum Chars{}pub enum Bytes{}pub enum Usize1{}pub enum Isize1{}}pub mod read{use crate::__cargo_equip::preludes::proconio::*;use crate::__cargo_equip::crates::proconio::marker::{Bytes,Chars,Isize1,Usize1};use crate::__cargo_equip::crates::proconio::source::{Readable,Source};use std::any::type_name;use std::fmt::Debug;use std::io::BufRead;use std::str::FromStr;implReadable for T where T::Err:Debug,{type Output=T;fn read>(source:&mut S)->T{let token=source.next_token_unwrap();match token.parse(){Ok(v)=>v,Err(e)=>panic!(concat!("failed to parse the input `{input}` ","to the value of type `{ty}`: {err:?}; ","ensure that the input format is collectly specified ","and that the input value must handle specified type.",),input=token,ty=type_name::(),err=e,),}}}impl Readable for Chars{type Output=Vec;fn read>(source:&mut S)->Vec{source.next_token_unwrap().chars().collect()}}impl Readable for Bytes{type Output=Vec;fn read>(source:&mut S)->Vec{source.next_token_unwrap().bytes().collect()}}impl Readable for Usize1{type Output=usize;fn read>(source:&mut S)->usize{usize::read(source)-1}}impl Readable for Isize1{type Output=isize;fn read>(source:&mut S)->isize{isize::read(source)-1}}}pub mod source{use crate::__cargo_equip::preludes::proconio::*;use std::io::BufRead;pub mod line{use crate::__cargo_equip::preludes::proconio::*;use super::Source;use std::io::BufRead;use std::iter::Peekable;use std::str::SplitWhitespace;pub struct LineSource{tokens:Peekable>,current_context:Box,reader:R,}implLineSource{pub fn new(reader:R)->LineSource{LineSource{current_context:"".to_string().into_boxed_str(),tokens:"".split_whitespace().peekable(),reader,}}fn prepare(&mut self){while self.tokens.peek().is_none(){let mut line=String::new();let num_bytes=self.reader.read_line(&mut line).expect("failed to get linel maybe an IO error.");if num_bytes==0{return;}self.current_context=line.into_boxed_str();self.tokens=unsafe{std::mem::transmute::<_,&'static str>(&*self.current_context)}.split_whitespace().peekable();}}}implSourcefor LineSource{fn next_token(&mut self)->Option<&str>{self.prepare();self.tokens.next()}fn is_empty(&mut self)->bool{self.prepare();self.tokens.peek().is_none()}}use std::io::BufReader;impl<'a>From<&'a str>for LineSource>{fn from(s:&'a str)->LineSource>{LineSource::new(BufReader::new(s.as_bytes()))}}}pub mod once{use crate::__cargo_equip::preludes::proconio::*;use super::Source;use std::io::BufRead;use std::iter::Peekable;use std::marker::PhantomData;use std::str::SplitWhitespace;pub struct OnceSource{tokens:Peekable>,context:Box,_read:PhantomData,}implOnceSource{pub fn new(mut source:R)->OnceSource{let mut context=String::new();source.read_to_string(&mut context).expect("failed to read from source; maybe an IO error.");let context=context.into_boxed_str();let mut res=OnceSource{context,tokens:"".split_whitespace().peekable(),_read:PhantomData,};use std::mem;let context:&'static str=unsafe{mem::transmute(&*res.context)};res.tokens=context.split_whitespace().peekable();res}}implSourcefor OnceSource{fn next_token(&mut self)->Option<&str>{self.tokens.next()}fn is_empty(&mut self)->bool{self.tokens.peek().is_none()}}use std::io::BufReader;impl<'a>From<&'a str>for OnceSource>{fn from(s:&'a str)->OnceSource>{OnceSource::new(BufReader::new(s.as_bytes()))}}}pub mod auto{use crate::__cargo_equip::preludes::proconio::*;#[cfg(debug_assertions)]pub use super::line::LineSource as AutoSource;#[cfg(not(debug_assertions))]pub use super::once::OnceSource as AutoSource;}pub trait Source{fn next_token(&mut self)->Option<&str>;fn is_empty(&mut self)->bool;fn next_token_unwrap(&mut self)->&str{self.next_token().expect(concat!("failed to get the next token; ","maybe reader reached an end of input. ","ensure that arguments for `input!` macro is correctly ","specified to match the problem input."))}}impl>Sourcefor&'_ mut S{fn next_token(&mut self)->Option<&str>{(*self).next_token()}fn is_empty(&mut self)->bool{(*self).is_empty()}}pub trait Readable{type Output;fn read>(source:&mut S)->Self::Output;}}use crate::__cargo_equip::crates::proconio::source::auto::AutoSource;use lazy_static::lazy_static;use std::io;use std::io::{BufReader,Stdin};use std::sync::Mutex;lazy_static!{#[doc(hidden)]pub static ref STDIN_SOURCE:Mutex>>=Mutex::new(AutoSource::new(BufReader::new(io::stdin())));}#[macro_export]macro_rules!__cargo_equip_macro_def_proconio_input{(@from[$source:expr]@rest)=>{};(@from[$source:expr]@rest mut$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::input!{@from[$source]@mut[mut]@rest$($rest)*}};(@from[$source:expr]@rest$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::input!{@from[$source]@mut[]@rest$($rest)*}};(@from[$source:expr]@mut[$($mut:tt)?]@rest$var:tt:$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::input!{@from[$source]@mut[$($mut)*]@var$var@kind[]@rest$($rest)*}};(@from[$source:expr]@mut[$($mut:tt)?]@var$var:tt@kind[$($kind:tt)*]@rest)=>{let$($mut)*$var=$crate::__cargo_equip::crates::proconio::read_value!(@source[$source]@kind[$($kind)*]);};(@from[$source:expr]@mut[$($mut:tt)?]@var$var:tt@kind[$($kind:tt)*]@rest,$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::input!(@from[$source]@mut[$($mut)*]@var$var@kind[$($kind)*]@rest);$crate::__cargo_equip::crates::proconio::input!(@from[$source]@rest$($rest)*);};(@from[$source:expr]@mut[$($mut:tt)?]@var$var:tt@kind[$($kind:tt)*]@rest$tt:tt$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::input!(@from[$source]@mut[$($mut)*]@var$var@kind[$($kind)*$tt]@rest$($rest)*);};(from$source:expr,$($rest:tt)*)=>{#[allow(unused_variables,unused_mut)]let mut s=$source;$crate::__cargo_equip::crates::proconio::input!{@from[&mut s]@rest$($rest)*}};($($rest:tt)*)=>{let mut locked_stdin=$crate::__cargo_equip::crates::proconio::STDIN_SOURCE.lock().expect(concat!("failed to lock the stdin; please re-run this program. ","If this issue repeatedly occur, this is a bug in `proconio`. ","Please report this issue from ","."));$crate::__cargo_equip::crates::proconio::input!{@from[&mut*locked_stdin]@rest$($rest)*}drop(locked_stdin);};}macro_rules!input{($($tt:tt)*)=>(crate::__cargo_equip_macro_def_proconio_input!{$($tt)*})}#[macro_export]macro_rules!__cargo_equip_macro_def_proconio_read_value{(@source[$source:expr]@kind[[$($kind:tt)*]])=>{$crate::__cargo_equip::crates::proconio::read_value!(@array@source[$source]@kind[]@rest$($kind)*)};(@array@source[$source:expr]@kind[$($kind:tt)*]@rest)=>{{let len=::read($source);$crate::__cargo_equip::crates::proconio::read_value!(@source[$source]@kind[[$($kind)*;len]])}};(@array@source[$source:expr]@kind[$($kind:tt)*]@rest;$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::read_value!(@array@source[$source]@kind[$($kind)*]@len[$($rest)*])};(@array@source[$source:expr]@kind[$($kind:tt)*]@rest$tt:tt$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::read_value!(@array@source[$source]@kind[$($kind)*$tt]@rest$($rest)*)};(@array@source[$source:expr]@kind[$($kind:tt)*]@len[$($len:tt)*])=>{{let len=$($len)*;(0..len).map(|_|$crate::__cargo_equip::crates::proconio::read_value!(@source[$source]@kind[$($kind)*])).collect::>()}};(@source[$source:expr]@kind[($($kinds:tt)*)])=>{$crate::__cargo_equip::crates::proconio::read_value!(@tuple@source[$source]@kinds[]@current[]@rest$($kinds)*)};(@tuple@source[$source:expr]@kinds[$([$($kind:tt)*])*]@current[]@rest)=>{($($crate::__cargo_equip::crates::proconio::read_value!(@source[$source]@kind[$($kind)*]),)*)};(@tuple@source[$source:expr]@kinds[$($kinds:tt)*]@current[$($curr:tt)*]@rest)=>{$crate::__cargo_equip::crates::proconio::read_value!(@tuple@source[$source]@kinds[$($kinds)*[$($curr)*]]@current[]@rest)};(@tuple@source[$source:expr]@kinds[$($kinds:tt)*]@current[$($curr:tt)*]@rest,$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::read_value!(@tuple@source[$source]@kinds[$($kinds)*[$($curr)*]]@current[]@rest$($rest)*)};(@tuple@source[$source:expr]@kinds[$($kinds:tt)*]@current[$($curr:tt)*]@rest$tt:tt$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::read_value!(@tuple@source[$source]@kinds[$($kinds)*]@current[$($curr)*$tt]@rest$($rest)*)};(@source[$source:expr]@kind[])=>{compile_error!(concat!("Reached unreachable statement while parsing macro input. ","This is a bug in `proconio`. ","Please report this issue from ","."));};(@source[$source:expr]@kind[$kind:ty])=>{<$kind as$crate::__cargo_equip::crates::proconio::source::Readable>::read($source)}}macro_rules!read_value{($($tt:tt)*)=>(crate::__cargo_equip_macro_def_proconio_read_value!{$($tt)*})}pub fn is_stdin_empty()->bool{use crate::__cargo_equip::crates::proconio::source::Source;let mut lock=STDIN_SOURCE.lock().expect(concat!("failed to lock the stdin; please re-run this program. ","If this issue repeatedly occur, this is a bug in `proconio`. ","Please report this issue from ","."));lock.is_empty()}} } pub(crate) mod macros { pub mod fixedbitset {} pub mod __lazy_static_1_4_0 {pub use crate::{__cargo_equip_macro_def___lazy_static_1_4_0___lazy_static_create as __lazy_static_create,__cargo_equip_macro_def___lazy_static_1_4_0___lazy_static_internal as __lazy_static_internal,__cargo_equip_macro_def___lazy_static_1_4_0_lazy_static as lazy_static};} pub mod proconio {pub use crate::{__cargo_equip_macro_def_proconio_input as input,__cargo_equip_macro_def_proconio_read_value as read_value};} } pub(crate) mod prelude {pub use crate::__cargo_equip::{crates::*,macros::__lazy_static_1_4_0::*};} mod preludes { pub mod fixedbitset {} pub mod __lazy_static_1_4_0 {pub(in crate::__cargo_equip)use crate::__cargo_equip::macros::__lazy_static_1_4_0::*;} pub mod proconio {pub(in crate::__cargo_equip)use crate::__cargo_equip::macros::__lazy_static_1_4_0::*;pub(in crate::__cargo_equip)use crate::__cargo_equip::crates::__lazy_static_1_4_0 as lazy_static;} } }