#1192018 (Rust) No.480 合計

• 問題: No.480 合計
• ユーザー: 39Y Nako
• 提出日時: 2026-10-09 02:38:39
• 言語: Rust (1.97.1 + proconio + num + itertools + ACL)
• 結果: AC
• 実行時間: 0 ms / 2,000 ms
• コード長: 40,376 bytes
• コンパイル時間: 6,818 ms
• コンパイル使用メモリ: 227,880 KB
• 実行使用メモリ: 9,904 KB
• 最終ジャッジ日時: 2026-10-09 02:38:51
• 合計ジャッジ時間: 3,974 ms
• ジャッジサーバーID （参考情報）: judge1_0 / judge4_0

ファイルパターン	結果
other	AC * 22

ソースコード

pub use __cargo_equip::prelude::*;

use proconio::{fastout, input};

#[fastout]
fn main() {
    input! {
        n: usize,
    }
    let ans = (n * (n + 1)) / 2;
    println!("{}", ans);
}

// The following code was expanded by `cargo-equip`.

///  # Bundled libraries
/// 
///  - `git+https://github.com/itto4869/cp_library.git?branch=rust-1.89.0#cp_library@0.1.0`                          licensed under `MIT`       as `crate::__cargo_equip::crates::__cp_library_0_1_0`
///  - `path+file:///home/itto/src/yukicoder/problems#0.1.0`                                published in **missing** licensed under **missing** as `crate::__cargo_equip::crates::problems`
#[cfg_attr(any(), rustfmt::skip)]
#[allow(unused)]
mod __cargo_equip {
    pub(crate) mod crates {
        pub mod __cp_library_0_1_0 {pub use crate::__cargo_equip::macros::__cp_library_0_1_0::*;pub mod algorithm{mod lis{pub fn lis<T:Ord>(seq:&[T])->usize{let mut dp:Vec<&T> =Vec::new();for x in seq{let idx=dp.partition_point(|item|*item<x);if idx<dp.len(){dp[idx]=x;}else{dp.push(x);}}dp.len()}}pub use lis::lis;}pub mod data_structure{pub mod arbitrary_binary_trie{#[derive(Clone,Debug,Default)]struct Node{children:[Option<usize>;2],count:usize,}#[derive(Clone,Debug)]pub struct ArbitraryBinaryTrie{nodes:Vec<Node>,root:usize,width:usize,}impl Default for ArbitraryBinaryTrie{fn default()->Self{Self::new()}}fn significant(bits:&[bool])->&[bool]{&bits[bits.iter().position(|&bit|bit).unwrap_or(bits.len())..]}fn padded(bits:&[bool],width:usize)->impl Iterator<Item=bool>+'_{std::iter::repeat_n(false,width-bits.len()).chain(bits.iter().copied())}impl ArbitraryBinaryTrie{pub fn new()->Self{Self{nodes:vec![Node::default()],root:0,width:0,}}pub fn len(&self)->usize{self.nodes[self.root].count}pub fn is_empty(&self)->bool{self.len()==0}pub fn clear(&mut self){*self=Self::new();}pub fn insert(&mut self,bits:&[bool]){let bits=significant(bits);while self.width<bits.len(){let root=self.nodes.len();self.nodes.push(Node{children:[Some(self.root),None],count:self.len(),});self.root=root;self.width+=1;}let mut node=self.root;self.nodes[node].count+=1;for bit in padded(bits,self.width){let branch=usize::from(bit);node=match self.nodes[node].children[branch]{Some(child)=>child,None=>{let child=self.nodes.len();self.nodes.push(Node::default());self.nodes[node].children[branch]=Some(child);child}};self.nodes[node].count+=1;}}pub fn count(&self,bits:&[bool])->usize{let bits=significant(bits);if bits.len()>self.width{return 0;}let mut node=self.root;for bit in padded(bits,self.width){match self.nodes[node].children[usize::from(bit)]{Some(child)=>node=child,None=>return 0,}}self.nodes[node].count}pub fn contains(&self,bits:&[bool])->bool{self.count(bits)>0}pub fn count_less(&self,bits:&[bool])->usize{self.count_inclusive(bits,false)}pub fn count_greater(&self,bits:&[bool])->usize{self.count_inclusive(bits,true)}fn count_inclusive(&self,bits:&[bool],greater:bool)->usize{let bits=significant(bits);if bits.len()>self.width{return if greater{0}else{self.len()};}let mut node=self.root;let mut count=0;for bit in padded(bits,self.width){if bit!=greater{if let Some(child)=self.nodes[node].children[usize::from(greater)]{count+=self.nodes[child].count;}}match self.nodes[node].children[usize::from(bit)]{Some(child)=>node=child,None=>return count,}}count+self.nodes[node].count}pub fn remove(&mut self,bits:&[bool])->bool{if!self.contains(bits){return false;}let bits=significant(bits);let mut node=self.root;self.nodes[node].count-=1;for bit in padded(bits,self.width){node=self.nodes[node].children[usize::from(bit)].unwrap();self.nodes[node].count-=1;}true}pub fn min_xor(&self,x:&[bool])->Option<Vec<bool>>{self.xor_extreme(x,false)}pub fn max_xor(&self,x:&[bool])->Option<Vec<bool>>{self.xor_extreme(x,true)}fn xor_extreme(&self,x:&[bool],maximize:bool)->Option<Vec<bool>>{if self.is_empty(){return None;}let x=significant(x);let extra=x.len().saturating_sub(self.width);let mut result=x[..extra].to_vec();let mut node=self.root;for bit in padded(&x[extra..],self.width){let preferred=usize::from(bit^maximize);let branch=if self.nodes[node].children[preferred].is_some_and(|child|self.nodes[child].count>0){preferred}else{preferred^1};result.push((branch!=0)^bit);node=self.nodes[node].children[branch].unwrap();}Some(significant(&result).to_vec())}}}pub mod binary_trie{#[derive(Clone,Debug,Default)]struct Node{children:[Option<usize>;2],count:usize,}#[derive(Clone,Debug)]pub struct BinaryTrie{nodes:Vec<Node>,}impl Default for BinaryTrie{fn default()->Self{Self::new()}}impl BinaryTrie{pub fn new()->Self{Self{nodes:vec![Node::default()],}}pub fn len(&self)->usize{self.nodes[0].count}pub fn is_empty(&self)->bool{self.len()==0}pub fn clear(&mut self){*self=Self::new();}pub fn insert(&mut self,value:u64){let mut node=0;self.nodes[node].count+=1;for bit in(0..64).rev(){let branch=((value>>bit)&1)as usize;let child=match self.nodes[node].children[branch]{Some(child)=>child,None=>{let child=self.nodes.len();self.nodes.push(Node::default());self.nodes[node].children[branch]=Some(child);child}};node=child;self.nodes[node].count+=1;}}pub fn count(&self,value:u64)->usize{let mut node=0;for bit in(0..64).rev(){let branch=((value>>bit)&1)as usize;match self.nodes[node].children[branch]{Some(child)=>node=child,None=>return 0,}}self.nodes[node].count}pub fn contains(&self,value:u64)->bool{self.count(value)>0}pub fn count_less(&self,value:u64)->usize{self.count_inclusive(value,false)}pub fn count_greater(&self,value:u64)->usize{self.count_inclusive(value,true)}fn count_inclusive(&self,value:u64,greater:bool)->usize{let mut node=0;let mut count=0;for bit in(0..64).rev(){let branch=((value>>bit)&1)as usize;if branch!=usize::from(greater){if let Some(child)=self.nodes[node].children[usize::from(greater)]{count+=self.nodes[child].count;}}match self.nodes[node].children[branch]{Some(child)=>node=child,None=>return count,}}count+self.nodes[node].count}pub fn remove(&mut self,value:u64)->bool{if!self.contains(value){return false;}let mut node=0;self.nodes[node].count-=1;for bit in(0..64).rev(){let branch=((value>>bit)&1)as usize;node=self.nodes[node].children[branch].unwrap();self.nodes[node].count-=1;}true}pub fn min_xor(&self,x:u64)->Option<u64>{self.xor_extreme(x,false)}pub fn max_xor(&self,x:u64)->Option<u64>{self.xor_extreme(x,true)}fn xor_extreme(&self,x:u64,maximize:bool)->Option<u64>{if self.is_empty(){return None;}let mut node=0;let mut result=0;for bit in(0..64).rev(){let x_bit=((x>>bit)&1)as usize;let preferred=x_bit^usize::from(maximize);let branch=if self.nodes[node].children[preferred].is_some_and(|child|self.nodes[child].count>0){preferred}else{preferred^1};result|=((branch^x_bit)as u64)<<bit;node=self.nodes[node].children[branch].unwrap();}Some(result)}}}pub mod implicit_treap{type Link<T> =Option<Box<Node<T>>>;#[derive(Clone,Debug)]struct Node<T>{value:T,priority:u64,size:usize,rev:bool,left:Link<T>,right:Link<T>,}impl<T>Node<T>{fn new(value:T,priority:u64)->Self{Self{value,priority,size:1,rev:false,left:None,right:None,}}fn size(node:&Link<T>)->usize{node.as_ref().map_or(0,|node|node.size)}fn update(node:&mut Box<Self>){node.size=1+Self::size(&node.left)+Self::size(&node.right);}fn toggle(node:&mut Link<T>){if let Some(node)=node{node.rev^=true;}}fn push(node:&mut Box<Self>){if!node.rev{return;}node.rev=false;std::mem::swap(&mut node.left,&mut node.right);Self::toggle(&mut node.left);Self::toggle(&mut node.right);}fn merge(left:Link<T>,right:Link<T>)->Link<T>{match(left,right){(None,right)=>right,(left,None)=>left,(Some(mut left),Some(mut right))=>{if left.priority>right.priority{Self::push(&mut left);left.right=Self::merge(left.right.take(),Some(right));Self::update(&mut left);Some(left)}else{Self::push(&mut right);right.left=Self::merge(Some(left),right.left.take());Self::update(&mut right);Some(right)}}}}fn split(root:Link<T>,left_size:usize)->(Link<T>,Link<T>){match root{None=>(None,None),Some(mut root)=>{Self::push(&mut root);let current_left_size=Self::size(&root.left);if left_size<=current_left_size{let(left,right)=Self::split(root.left.take(),left_size);root.left=right;Self::update(&mut root);(left,Some(root))}else{let(left,right)=Self::split(root.right.take(),left_size-current_left_size-1);root.right=left;Self::update(&mut root);(Some(root),right)}}}}fn get(node:&mut Link<T>,index:usize)->Option<&T>{let node=node.as_mut()?;Self::push(node);let left_size=Self::size(&node.left);match index.cmp(&left_size){std::cmp::Ordering::Less=>Self::get(&mut node.left,index),std::cmp::Ordering::Equal=>Some(&node.value),std::cmp::Ordering::Greater=>Self::get(&mut node.right,index-left_size-1),}}fn get_mut(node:&mut Link<T>,index:usize)->Option<&mut T>{let node=node.as_mut()?;Self::push(node);let left_size=Self::size(&node.left);match index.cmp(&left_size){std::cmp::Ordering::Less=>Self::get_mut(&mut node.left,index),std::cmp::Ordering::Equal=>Some(&mut node.value),std::cmp::Ordering::Greater=>Self::get_mut(&mut node.right,index-left_size-1),}}fn collect(node:&mut Link<T>,out:&mut Vec<T>)where T:Clone,{if let Some(node)=node{Self::push(node);Self::collect(&mut node.left,out);out.push(node.value.clone());Self::collect(&mut node.right,out);}}fn collect_into(mut node:Box<Self>,out:&mut Vec<T>){Self::push(&mut node);let Node{value,left,right,..}=*node;if let Some(left)=left{Self::collect_into(left,out);}out.push(value);if let Some(right)=right{Self::collect_into(right,out);}}}#[derive(Clone,Debug)]pub struct ImplicitTreap<T>{root:Link<T>,seed:u64,}impl<T>Default for ImplicitTreap<T>{fn default()->Self{Self::new()}}impl<T>ImplicitTreap<T>{const DEFAULT_SEED:u64=0x9e37_79b9_7f4a_7c15;pub fn new()->Self{Self::with_seed(Self::DEFAULT_SEED)}pub fn with_seed(seed:u64)->Self{Self{root:None,seed}}pub fn len(&self)->usize{Node::size(&self.root)}pub fn is_empty(&self)->bool{self.root.is_none()}pub fn push_front(&mut self,value:T){self.insert(0,value);}pub fn push_back(&mut self,value:T){self.insert(self.len(),value);}pub fn insert(&mut self,index:usize,value:T){assert!(index<=self.len());let node=Some(Box::new(Node::new(value,self.next_priority())));let(left,right)=Node::split(self.root.take(),index);self.root=Node::merge(Node::merge(left,node),right);}pub fn remove(&mut self,index:usize)->Option<T>{if index>=self.len(){return None;}let(left,rest)=Node::split(self.root.take(),index);let(middle,right)=Node::split(rest,1);self.root=Node::merge(left,right);middle.map(|node|{let Node{value,..}=*node;value})}pub fn get(&mut self,index:usize)->Option<&T>{if index>=self.len(){return None;}Node::get(&mut self.root,index)}pub fn get_mut(&mut self,index:usize)->Option<&mut T>{if index>=self.len(){return None;}Node::get_mut(&mut self.root,index)}pub fn set(&mut self,index:usize,value:T)->bool{if let Some(current)=self.get_mut(index){*current=value;true}else{false}}pub fn reverse(&mut self,left:usize,right:usize){assert!(left<=right);assert!(right<=self.len());if left==right{return;}let(prefix,rest)=Node::split(self.root.take(),left);let(mut middle,suffix)=Node::split(rest,right-left);Node::toggle(&mut middle);self.root=Node::merge(prefix,Node::merge(middle,suffix));}pub fn clear(&mut self){self.root=None;}pub fn to_vec(&mut self)->Vec<T>where T:Clone,{let mut values=Vec::with_capacity(self.len());Node::collect(&mut self.root,&mut values);values}pub fn into_vec(self)->Vec<T>{let mut values=Vec::with_capacity(Node::size(&self.root));if let Some(root)=self.root{Node::collect_into(root,&mut values);}values}fn next_priority(&mut self)->u64{self.seed=self.seed.wrapping_add(0x9e37_79b9_7f4a_7c15);let mut value=self.seed;value=(value^(value>>30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);value=(value^(value>>27)).wrapping_mul(0x94d0_49bb_1331_11eb);value^(value>>31)}}impl<T>Extend<T>for ImplicitTreap<T>{fn extend<I>(&mut self,iter:I)where I:IntoIterator<Item=T>,{for value in iter{self.push_back(value);}}}impl<T>std::iter::FromIterator<T>for ImplicitTreap<T>{fn from_iter<I>(iter:I)->Self where I:IntoIterator<Item=T>,{let mut treap=Self::new();treap.extend(iter);treap}}impl<T>From<Vec<T>>for ImplicitTreap<T>{fn from(values:Vec<T>)->Self{values.into_iter().collect()}}}pub mod intervalset{use std::collections::BTreeSet;#[derive(Clone,Debug,Default,PartialEq,Eq)]pub struct IntervalSet{intervals:BTreeSet<(i64,i64)>,}impl IntervalSet{pub fn new()->Self{Self::default()}pub fn len(&self)->usize{self.intervals.len()}pub fn is_empty(&self)->bool{self.intervals.is_empty()}pub fn clear(&mut self){self.intervals.clear();}pub fn iter(&self)->impl DoubleEndedIterator<Item=(i64,i64)>+ExactSizeIterator+'_{self.intervals.iter().copied()}pub fn interval_containing(&self,point:i64)->Option<(i64,i64)>{self.intervals.range(..=(point,i64::MAX)).next_back().copied().filter(|&(_,r)|point<r)}pub fn contains(&self,point:i64)->bool{self.interval_containing(point).is_some()}pub fn contains_range(&self,l:i64,r:i64)->bool{assert!(l<=r,"interval endpoints must satisfy l <= r");l==r||self.interval_containing(l).is_some_and(|(_,end)|r<=end)}pub fn insert(&mut self,mut l:i64,mut r:i64){assert!(l<=r,"interval endpoints must satisfy l <= r");if l==r{return;}if let Some((start,end))=self.intervals.range(..=(l,i64::MAX)).next_back().copied(){if end>=l{self.intervals.remove(&(start,end));l=start;r=r.max(end);}}while let Some((start,end))=self.intervals.range((l,i64::MIN)..).next().copied(){if start>r{break;}self.intervals.remove(&(start,end));r=r.max(end);}self.intervals.insert((l,r));}pub fn remove(&mut self,l:i64,r:i64){assert!(l<=r,"interval endpoints must satisfy l <= r");if l==r{return;}if let Some((start,end))=self.interval_containing(l){self.intervals.remove(&(start,end));if start<l{self.intervals.insert((start,l));}if end>r{self.intervals.insert((r,end));return;}}while let Some((start,end))=self.intervals.range((l,i64::MIN)..).next().copied(){if start>=r{break;}self.intervals.remove(&(start,end));if end>r{self.intervals.insert((r,end));break;}}}}}pub mod lazy_reversible_rbst{pub trait LazyReversibleRbstSpec{type Value:Clone;type Action:Clone;fn identity()->Self::Value;fn combine(left:&Self::Value,right:&Self::Value)->Self::Value;fn apply(action:&Self::Action,value:&Self::Value,len:usize)->Self::Value;fn compose(new:&Self::Action,old:&Self::Action)->Self::Action;}type Link<S> =Option<Box<Node<S>>>;struct Node<S>where S:LazyReversibleRbstSpec,{value:S::Value,product:S::Value,reverse_product:S::Value,lazy:Option<S::Action>,size:usize,reversed:bool,left:Link<S>,right:Link<S>,}impl<S>Clone for Node<S>where S:LazyReversibleRbstSpec,{fn clone(&self)->Self{Self{value:self.value.clone(),product:self.product.clone(),reverse_product:self.reverse_product.clone(),lazy:self.lazy.clone(),size:self.size,reversed:self.reversed,left:self.left.clone(),right:self.right.clone(),}}}impl<S>Node<S>where S:LazyReversibleRbstSpec,{fn new(value:S::Value)->Self{Self{product:value.clone(),reverse_product:value.clone(),value,lazy:None,size:1,reversed:false,left:None,right:None,}}fn size(node:&Link<S>)->usize{node.as_ref().map_or(0,|node|node.size)}fn product(node:&Link<S>)->S::Value{node.as_ref().map_or_else(S::identity,|node|node.product.clone())}fn reverse_product(node:&Link<S>)->S::Value{node.as_ref().map_or_else(S::identity,|node|node.reverse_product.clone())}fn update(node:&mut Box<Self>){node.size=1+Self::size(&node.left)+Self::size(&node.right);let left_product=Self::product(&node.left);let right_product=Self::product(&node.right);node.product=S::combine(&S::combine(&left_product,&node.value),&right_product);let right_reverse_product=Self::reverse_product(&node.right);let left_reverse_product=Self::reverse_product(&node.left);node.reverse_product=S::combine(&S::combine(&right_reverse_product,&node.value),&left_reverse_product,);}fn apply_action(node:&mut Link<S>,action:&S::Action){let Some(node)=node else{return;};node.value=S::apply(action,&node.value,1);node.product=S::apply(action,&node.product,node.size);node.reverse_product=S::apply(action,&node.reverse_product,node.size);node.lazy=Some(match node.lazy.take(){Some(old)=>S::compose(action,&old),None=>action.clone(),});}fn toggle(node:&mut Link<S>){let Some(node)=node else{return;};std::mem::swap(&mut node.left,&mut node.right);std::mem::swap(&mut node.product,&mut node.reverse_product);node.reversed^=true;}fn push(node:&mut Box<Self>){if node.reversed{Self::toggle(&mut node.left);Self::toggle(&mut node.right);node.reversed=false;}if let Some(action)=node.lazy.take(){Self::apply_action(&mut node.left,&action);Self::apply_action(&mut node.right,&action);}}fn merge(left:Link<S>,right:Link<S>,random:&mut Random)->Link<S>{match(left,right){(None,right)=>right,(left,None)=>left,(Some(mut left),Some(mut right))=>{let left_size=left.size;let total_size=left_size+right.size;if random.index(total_size)<left_size{Self::push(&mut left);left.right=Self::merge(left.right.take(),Some(right),random);Self::update(&mut left);Some(left)}else{Self::push(&mut right);right.left=Self::merge(Some(left),right.left.take(),random);Self::update(&mut right);Some(right)}}}}fn split(root:Link<S>,left_size:usize)->(Link<S>,Link<S>){match root{None=>(None,None),Some(mut root)=>{Self::push(&mut root);let current_left_size=Self::size(&root.left);if left_size<=current_left_size{let(left,right)=Self::split(root.left.take(),left_size);root.left=right;Self::update(&mut root);(left,Some(root))}else{let(left,right)=Self::split(root.right.take(),left_size-current_left_size-1);root.right=left;Self::update(&mut root);(Some(root),right)}}}}fn build(values:&mut[Option<S::Value>],left:usize,right:usize,random:&mut Random,)->Link<S>{if left==right{return None;}let root_index=left+random.index(right-left);let value=values[root_index].take().expect("each value is used exactly once while building");let mut root=Box::new(Self::new(value));root.left=Self::build(values,left,root_index,random);root.right=Self::build(values,root_index+1,right,random);Self::update(&mut root);Some(root)}fn get(node:&mut Link<S>,index:usize)->Option<&S::Value>{let node=node.as_mut()?;Self::push(node);let left_size=Self::size(&node.left);match index.cmp(&left_size){std::cmp::Ordering::Less=>Self::get(&mut node.left,index),std::cmp::Ordering::Equal=>Some(&node.value),std::cmp::Ordering::Greater=>Self::get(&mut node.right,index-left_size-1),}}fn set(node:&mut Box<Self>,index:usize,value:S::Value){Self::push(node);let left_size=Self::size(&node.left);match index.cmp(&left_size){std::cmp::Ordering::Less=>{Self::set(node.left.as_mut().expect("the index was checked before descending"),index,value,);}std::cmp::Ordering::Equal=>node.value=value,std::cmp::Ordering::Greater=>{Self::set(node.right.as_mut().expect("the index was checked before descending"),index-left_size-1,value,);}}Self::update(node);}fn collect(node:&mut Link<S>,output:&mut Vec<S::Value>){if let Some(node)=node{Self::push(node);Self::collect(&mut node.left,output);output.push(node.value.clone());Self::collect(&mut node.right,output);}}fn collect_into(mut node:Box<Self>,output:&mut Vec<S::Value>){Self::push(&mut node);let Self{value,left,right,..}=*node;if let Some(left)=left{Self::collect_into(left,output);}output.push(value);if let Some(right)=right{Self::collect_into(right,output);}}}#[derive(Clone)]struct Random{state:u64,}impl Random{fn new(seed:u64)->Self{Self{state:seed}}fn next(&mut self)->u64{self.state=self.state.wrapping_add(0x9e37_79b9_7f4a_7c15);let mut value=self.state;value=(value^(value>>30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);value=(value^(value>>27)).wrapping_mul(0x94d0_49bb_1331_11eb);value^(value>>31)}fn index(&mut self,upper_bound:usize)->usize{debug_assert!(upper_bound>0);let upper_bound=upper_bound as u64;let rejection_threshold=upper_bound.wrapping_neg()%upper_bound;loop{let product=self.next()as u128*upper_bound as u128;if product as u64>=rejection_threshold{return(product>>64)as usize;}}}}pub struct LazyReversibleRbst<S>where S:LazyReversibleRbstSpec,{root:Link<S>,random:Random,}impl<S>Clone for LazyReversibleRbst<S>where S:LazyReversibleRbstSpec,{fn clone(&self)->Self{Self{root:self.root.clone(),random:self.random.clone(),}}}impl<S>Default for LazyReversibleRbst<S>where S:LazyReversibleRbstSpec,{fn default()->Self{Self::new()}}impl<S>LazyReversibleRbst<S>where S:LazyReversibleRbstSpec,{const DEFAULT_SEED:u64=0x243f_6a88_85a3_08d3;pub fn new()->Self{Self::with_seed(Self::DEFAULT_SEED)}pub fn with_seed(seed:u64)->Self{Self{root:None,random:Random::new(seed),}}pub fn from_iter_with_seed<I>(iter:I,seed:u64)->Self where I:IntoIterator<Item=S::Value>,{let mut values:Vec<_> =iter.into_iter().map(Some).collect();let mut random=Random::new(seed);let len=values.len();let root=Node::build(&mut values,0,len,&mut random);Self{root,random}}pub fn len(&self)->usize{Node::size(&self.root)}pub fn is_empty(&self)->bool{self.root.is_none()}pub fn push_front(&mut self,value:S::Value){self.insert(0,value);}pub fn push_back(&mut self,value:S::Value){self.insert(self.len(),value);}pub fn insert(&mut self,index:usize,value:S::Value){assert!(index<=self.len(),"insertion index out of bounds");let(left,right)=Node::split(self.root.take(),index);let middle=Some(Box::new(Node::new(value)));let left=Node::merge(left,middle,&mut self.random);self.root=Node::merge(left,right,&mut self.random);}pub fn remove(&mut self,index:usize)->Option<S::Value>{if index>=self.len(){return None;}let(left,rest)=Node::split(self.root.take(),index);let(middle,right)=Node::split(rest,1);self.root=Node::merge(left,right,&mut self.random);middle.map(|node|node.value)}pub fn get(&mut self,index:usize)->Option<&S::Value>{if index>=self.len(){return None;}Node::get(&mut self.root,index)}pub fn set(&mut self,index:usize,value:S::Value)->bool{if index>=self.len(){return false;}Node::set(self.root.as_mut().expect("a valid index implies a non-empty tree"),index,value,);true}pub fn fold(&mut self,left:usize,right:usize)->S::Value{self.assert_range(left,right);if left==right{return S::identity();}let(prefix,rest)=Node::split(self.root.take(),left);let(middle,suffix)=Node::split(rest,right-left);let result=Node::product(&middle);let rest=Node::merge(middle,suffix,&mut self.random);self.root=Node::merge(prefix,rest,&mut self.random);result}pub fn prod(&mut self,left:usize,right:usize)->S::Value{self.fold(left,right)}pub fn all_prod(&self)->S::Value{Node::product(&self.root)}pub fn apply(&mut self,left:usize,right:usize,action:S::Action){self.assert_range(left,right);if left==right{return;}let(prefix,rest)=Node::split(self.root.take(),left);let(mut middle,suffix)=Node::split(rest,right-left);Node::apply_action(&mut middle,&action);let rest=Node::merge(middle,suffix,&mut self.random);self.root=Node::merge(prefix,rest,&mut self.random);}pub fn reverse(&mut self,left:usize,right:usize){self.assert_range(left,right);if left==right{return;}let(prefix,rest)=Node::split(self.root.take(),left);let(mut middle,suffix)=Node::split(rest,right-left);Node::toggle(&mut middle);let rest=Node::merge(middle,suffix,&mut self.random);self.root=Node::merge(prefix,rest,&mut self.random);}pub fn reverse_all(&mut self){Node::toggle(&mut self.root);}pub fn split_off(&mut self,index:usize)->Self{assert!(index<=self.len(),"split index out of bounds");let(left,right)=Node::split(self.root.take(),index);self.root=left;Self{root:right,random:Random::new(self.random.next()),}}pub fn append(&mut self,other:&mut Self){self.root=Node::merge(self.root.take(),other.root.take(),&mut self.random);}pub fn clear(&mut self){self.root=None;}pub fn to_vec(&mut self)->Vec<S::Value>{let mut values=Vec::with_capacity(self.len());Node::collect(&mut self.root,&mut values);values}pub fn into_vec(self)->Vec<S::Value>{let mut values=Vec::with_capacity(Node::size(&self.root));if let Some(root)=self.root{Node::collect_into(root,&mut values);}values}fn assert_range(&self,left:usize,right:usize){assert!(left<=right,"range start exceeds range end");assert!(right<=self.len(),"range end out of bounds");}}impl<S>Extend<S::Value>for LazyReversibleRbst<S>where S:LazyReversibleRbstSpec,{fn extend<I>(&mut self,iter:I)where I:IntoIterator<Item=S::Value>,{for value in iter{self.push_back(value);}}}impl<S>FromIterator<S::Value>for LazyReversibleRbst<S>where S:LazyReversibleRbstSpec,{fn from_iter<I>(iter:I)->Self where I:IntoIterator<Item=S::Value>,{Self::from_iter_with_seed(iter,Self::DEFAULT_SEED)}}impl<S>From<Vec<S::Value>>for LazyReversibleRbst<S>where S:LazyReversibleRbstSpec,{fn from(values:Vec<S::Value>)->Self{values.into_iter().collect()}}}pub mod lazy_segtree_map_monoid{use ac_library::{MapMonoid,Monoid};use std::marker::PhantomData;use std::ops::{Add,Mul};#[derive(Clone,Copy,Debug,PartialEq,Eq)]pub struct SumLen<T=i64>{pub sum:T,pub len:usize,}impl<T>SumLen<T>{pub fn new(value:T)->Self{Self{sum:value,len:1}}}#[derive(Clone,Copy,Debug)]pub struct SumMonoid<T=i64>(PhantomData<T>);impl<T:Copy+From<i64>+Add<Output=T>>Monoid for SumMonoid<T>{type S=SumLen<T>;fn identity()->Self::S{SumLen{sum:T::from(0),len:0,}}fn binary_operation(a:&Self::S,b:&Self::S)->Self::S{SumLen{sum:a.sum+b.sum,len:a.len+b.len,}}}#[derive(Clone,Copy,Debug)]pub struct RangeAddSum<T=i64>(PhantomData<T>);impl<T>MapMonoid for RangeAddSum<T>where T:Copy+From<i64>+Add<Output=T>+Mul<Output=T>,{type M=SumMonoid<T>;type F=T;fn identity_map()->T{T::from(0)}fn mapping(f:&T,x:&SumLen<T>)->SumLen<T>{SumLen{sum:x.sum+*f*T::from(i64::try_from(x.len).expect("length exceeds i64")),len:x.len,}}fn composition(f:&T,g:&T)->T{*f+*g}}#[derive(Clone,Copy,Debug)]pub struct RangeAssignSum<T=i64>(PhantomData<T>);impl<T>MapMonoid for RangeAssignSum<T>where T:Copy+From<i64>+Add<Output=T>+Mul<Output=T>,{type M=SumMonoid<T>;type F=Option<T>;fn identity_map()->Self::F{None}fn mapping(f:&Self::F,x:&SumLen<T>)->SumLen<T>{match f{Some(value)=>SumLen{sum:*value*T::from(i64::try_from(x.len).expect("length exceeds i64")),len:x.len,},None=>*x,}}fn composition(f:&Self::F,g:&Self::F)->Self::F{f.or(*g)}}#[derive(Clone,Copy,Debug)]pub struct RangeAffineSum<T=i64>(PhantomData<T>);impl<T>MapMonoid for RangeAffineSum<T>where T:Copy+From<i64>+Add<Output=T>+Mul<Output=T>,{type M=SumMonoid<T>;type F=(T,T);fn identity_map()->Self::F{(T::from(1),T::from(0))}fn mapping(f:&Self::F,x:&SumLen<T>)->SumLen<T>{SumLen{sum:f.0*x.sum+f.1*T::from(i64::try_from(x.len).expect("length exceeds i64")),len:x.len,}}fn composition(f:&Self::F,g:&Self::F)->Self::F{(f.0*g.0,f.0*g.1+f.1)}}macro_rules!extrema{($monoid:ident,$add:ident,$assign:ident,$op:ident,$doc:literal)=>{#[doc=$doc]#[doc=" `None` is the empty segment; use `Some(value)` for ordinary leaves."]#[derive(Clone,Copy,Debug)]pub struct$monoid;impl Monoid for$monoid{type S=Option<i64>;fn identity()->Self::S{None}fn binary_operation(a:&Self::S,b:&Self::S)->Self::S{match(*a,*b){(Some(a),Some(b))=>Some(a.$op(b)),(a,b)=>a.or(b),}}}#[doc=concat!("Range addition with `",stringify!($monoid),"`. Action: `i64`.")]#[derive(Clone,Copy,Debug)]pub struct$add;impl MapMonoid for$add{type M=$monoid;type F=i64;fn identity_map()->Self::F{0}fn mapping(f:&Self::F,x:&Option<i64>)->Option<i64>{x.map(|x|x+*f)}fn composition(f:&Self::F,g:&Self::F)->Self::F{*f+*g}}#[doc=concat!("Range assignment with `",stringify!($monoid),"`. `None` is the identity action.")]#[derive(Clone,Copy,Debug)]pub struct$assign;impl MapMonoid for$assign{type M=$monoid;type F=Option<i64>;fn identity_map()->Self::F{None}fn mapping(f:&Self::F,x:&Option<i64>)->Option<i64>{x.map(|x|f.unwrap_or(x))}fn composition(f:&Self::F,g:&Self::F)->Self::F{f.or(*g)}}};}extrema!(MinMonoid,RangeAddMin,RangeAssignMin,min,"Minimum monoid for i64.");extrema!(MaxMonoid,RangeAddMax,RangeAssignMax,max,"Maximum monoid for i64.");}pub mod trie{use std::collections::BTreeMap;#[derive(Clone,Debug,Default)]struct Node{children:BTreeMap<char,usize>,count:usize,terminal_count:usize,}#[derive(Clone,Debug)]pub struct Trie{nodes:Vec<Node>,}impl Default for Trie{fn default()->Self{Self::new()}}impl Trie{pub fn new()->Self{Self{nodes:vec![Node::default()],}}pub fn len(&self)->usize{self.nodes[0].count}pub fn is_empty(&self)->bool{self.len()==0}pub fn clear(&mut self){*self=Self::new();}pub fn insert(&mut self,word:&str){let mut node=0;self.nodes[node].count+=1;for ch in word.chars(){let child=match self.nodes[node].children.get(&ch){Some(&child)=>child,None=>{let child=self.nodes.len();self.nodes.push(Node::default());self.nodes[node].children.insert(ch,child);child}};node=child;self.nodes[node].count+=1;}self.nodes[node].terminal_count+=1;}fn find(&self,text:&str)->Option<usize>{let mut node=0;for ch in text.chars(){node=*self.nodes[node].children.get(&ch)?;}Some(node)}pub fn count(&self,word:&str)->usize{self.find(word).map_or(0,|node|self.nodes[node].terminal_count)}pub fn contains(&self,word:&str)->bool{self.count(word)>0}pub fn count_less(&self,word:&str)->usize{let(less,equal)=self.count_before_and_equal(word);less+equal}pub fn count_greater(&self,word:&str)->usize{let(less,_)=self.count_before_and_equal(word);self.len()-less}fn count_before_and_equal(&self,word:&str)->(usize,usize){let mut node=0;let mut less=0;for ch in word.chars(){less+=self.nodes[node].terminal_count;for(_,&child)in self.nodes[node].children.range(..ch){less+=self.nodes[child].count;}match self.nodes[node].children.get(&ch){Some(&child)=>node=child,None=>return(less,0),}}(less,self.nodes[node].terminal_count)}pub fn prefix_count(&self,prefix:&str)->usize{self.find(prefix).map_or(0,|node|self.nodes[node].count)}pub fn starts_with(&self,prefix:&str)->bool{self.prefix_count(prefix)>0}pub fn remove(&mut self,word:&str)->bool{if!self.contains(word){return false;}let mut node=0;self.nodes[node].count-=1;for ch in word.chars(){node=self.nodes[node].children[&ch];self.nodes[node].count-=1;}self.nodes[node].terminal_count-=1;true}}}pub mod weighted_dsu{use std::ops::{Add,Neg,Sub};#[derive(Clone,Debug)]pub struct WeightedDsu<T>{parent_or_size:Vec<i32>,diff_weight:Vec<T>,}impl<T>WeightedDsu<T>where T:Copy+Default+Add<Output=T>+Sub<Output=T>+Neg<Output=T>,{pub fn new(size:usize)->Self{Self{parent_or_size:vec![-1;size],diff_weight:vec![T::default();size],}}pub fn find(&mut self,x:usize)->usize{if self.parent_or_size[x]<0{return x;}let p=self.parent_or_size[x]as usize;let root=self.find(p);self.diff_weight[x]=self.diff_weight[x]+self.diff_weight[p];self.parent_or_size[x]=root as i32;root}pub fn weight(&mut self,x:usize)->T{self.find(x);self.diff_weight[x]}pub fn diff(&mut self,x:usize,y:usize)->Option<T>{if self.same(x,y){Some(self.weight(y)-self.weight(x))}else{None}}pub fn same(&mut self,x:usize,y:usize)->bool{self.find(x)==self.find(y)}pub fn merge(&mut self,mut x:usize,mut y:usize,mut w:T)->bool{let root_x=self.find(x);let root_y=self.find(y);if root_x==root_y{return false;}w=w+self.weight(x)-self.weight(y);x=root_x;y=root_y;if-self.parent_or_size[x]< -self.parent_or_size[y]{std::mem::swap(&mut x,&mut y);w=-w;}self.parent_or_size[x]+=self.parent_or_size[y];self.parent_or_size[y]=x as i32;self.diff_weight[y]=w;true}pub fn size(&mut self,x:usize)->usize{let root=self.find(x);-self.parent_or_size[root]as usize}}}}pub mod graph{pub mod dijkstra{use std::cmp::Reverse;use std::collections::BinaryHeap;pub fn dijkstra(graph:&[Vec<(usize,usize)>],start:usize)->Vec<usize>{let n=graph.len();assert!(start<n,"start vertex is out of bounds");for edges in graph{for&(to,_)in edges{assert!(to<n,"edge destination is out of bounds");}}let mut distances=vec![usize::MAX;n];let mut queue=BinaryHeap::new();distances[start]=0;queue.push(Reverse((0,start)));while let Some(Reverse((distance,vertex)))=queue.pop(){if distance!=distances[vertex]{continue;}for&(to,cost)in&graph[vertex]{let next_distance=distance.saturating_add(cost);if next_distance<distances[to]{distances[to]=next_distance;queue.push(Reverse((next_distance,to)));}}}distances}}pub mod functional_graph{#[derive(Clone,Debug)]pub struct FunctionalGraph{next:Vec<usize>,}impl FunctionalGraph{pub fn new(next:Vec<usize>)->Self{assert!(next.iter().all(|&to|to<next.len()),"edge destination is out of bounds");Self{next}}pub fn len(&self)->usize{self.next.len()}pub fn is_empty(&self)->bool{self.next.is_empty()}pub fn next(&self,vertex:usize)->usize{self.next[vertex]}pub fn cycles(&self)->Vec<Vec<usize>>{let mut indegree=vec![0usize;self.len()];for&to in&self.next{indegree[to]+=1;}let mut queue:Vec<usize> =(0..self.len()).filter(|&v|indegree[v]==0).collect();let mut head=0;while head<queue.len(){let to=self.next[queue[head]];head+=1;indegree[to]-=1;if indegree[to]==0{queue.push(to);}}let mut cycles=Vec::new();for start in 0..self.len(){if indegree[start]==0{continue;}let mut cycle=Vec::new();let mut vertex=start;loop{cycle.push(vertex);indegree[vertex]=0;vertex=self.next[vertex];if vertex==start{break;}}cycles.push(cycle);}cycles}}}pub use dijkstra::dijkstra;pub use functional_graph::FunctionalGraph;}pub mod grid{pub fn neighbors4(r:usize,c:usize,h:usize,w:usize)->Vec<(usize,usize)>{let mut neighbors=Vec::with_capacity(4);let dr=[0,0,1,!0];let dc=[1,!0,0,0];for i in 0..4{let nr=r.wrapping_add(dr[i]);let nc=c.wrapping_add(dc[i]);if nr<h&&nc<w{neighbors.push((nr,nc));}}neighbors}pub fn neighbors8(r:usize,c:usize,h:usize,w:usize)->Vec<(usize,usize)>{let mut neighbors=Vec::with_capacity(8);for dr in[!0,0,1]{for dc in[!0,0,1]{if dr==0&&dc==0{continue;}let nr=r.wrapping_add(dr);let nc=c.wrapping_add(dc);if nr<h&&nc<w{neighbors.push((nr,nc));}}}neighbors}}pub mod math{pub mod base_conversion{pub fn convert_base<T:std::fmt::Display>(num:T,n:u32,m:u32)->Result<String,&'static str>{let s=num.to_string();let s=s.trim();if n<2||n>36||m<2||m>36{return Err("Bases must be between 2 and 36");}if s.is_empty(){return Err("Empty input");}let is_negative=s.starts_with('-');let mut s=if is_negative{&s[1..]}else{s};while s.starts_with('0')&&s.len()>1{s=&s[1..];}let mut digits=vec![];for c in s.chars(){let val=c.to_digit(n).ok_or("Invalid character for base n")?;digits.push(val);}if digits.is_empty()||digits.iter().all(|&d|d==0){return Ok("0".to_string());}let mut res=String::new();let chars_map=b"0123456789abcdefghijklmnopqrstuvwxyz";while!digits.is_empty(){let mut rem=0;let mut next_digits=vec![];for&d in&digits{let cur=rem*n+d;let div=cur/m;rem=cur%m;if!next_digits.is_empty()||div>0{next_digits.push(div);}}res.push(chars_map[rem as usize]as char);digits=next_digits;}if is_negative&&res!="0"{res.push('-');}Ok(res.chars().rev().collect())}}pub mod combinations{pub struct Combination{fact:Vec<u64>,inv_fact:Vec<u64>,modulo:u64,}impl Combination{pub fn new(max_n:usize,modulo:u64)->Self{let mut fact=vec![1;max_n+1];let mut inv_fact=vec![1;max_n+1];for i in 1..=max_n{fact[i]=(fact[i-1]*i as u64)%modulo;}inv_fact[max_n]=Self::mod_pow(fact[max_n],modulo-2,modulo);for i in(1..=max_n).rev(){inv_fact[i-1]=(inv_fact[i]*i as u64)%modulo;}Combination{fact,inv_fact,modulo,}}pub fn n_c_r(&self,n:usize,r:usize)->u64{if r>n{return 0;}let numer=self.fact[n];let denom=(self.inv_fact[r]*self.inv_fact[n-r])%self.modulo;(numer*denom)%self.modulo}pub fn n_p_r(&self,n:usize,r:usize)->u64{if r>n{return 0;}let numer=self.fact[n];let denom=self.inv_fact[n-r];(numer*denom)%self.modulo}pub fn n_h_r(&self,n:usize,r:usize)->u64{if n==0&&r==0{return 1;}if n==0{return 0;}self.n_c_r(n+r-1,r)}pub fn fact(&self,n:usize)->u64{self.fact[n]}pub fn inv_fact(&self,n:usize)->u64{self.inv_fact[n]}fn mod_pow(mut base:u64,mut exp:u64,modulo:u64)->u64{let mut res=1;base%=modulo;while exp>0{if exp%2==1{res=(res*base)%modulo;}base=(base*base)%modulo;exp/=2;}res}}}pub mod numeric{pub trait GCD{fn gcd(self,other:Self)->Self;fn lcm(self,other:Self)->Self;}macro_rules!impl_gcd{($($t:ty),*)=>{$(impl GCD for$t{fn gcd(self,other:Self)->Self{let mut a=self;let mut b=other;while b!=0{let t=b;b=a%b;a=t;}a}fn lcm(self,other:Self)->Self{if self==0&&other==0{return 0;}(self/self.gcd(other))*other}})*};}impl_gcd!(u8,u16,u32,u64,u128,usize,i8,i16,i32,i64,i128,isize);pub fn gcd<T:GCD>(a:T,b:T)->T{a.gcd(b)}pub fn lcm<T:GCD>(a:T,b:T)->T{a.lcm(b)}}pub mod prime_enumeration{pub fn enumerate_primes(upper_bound:usize)->Vec<usize>{if upper_bound<2{return Vec::new();}let mut is_prime=vec![true;upper_bound+1];is_prime[0]=false;is_prime[1]=false;let mut prime=2;while prime<=upper_bound/prime{if is_prime[prime]{for multiple in(prime*prime..=upper_bound).step_by(prime){is_prime[multiple]=false;}}prime+=1;}is_prime.into_iter().enumerate().filter_map(|(number,prime)|prime.then_some(number)).collect()}}pub mod prime_factorization{pub fn prime_factorize(n:u64)->Vec<(u64,u32)>{assert!(n>0,"zero has no prime factorization");let mut factors=Vec::new();collect_prime_factors(n,&mut factors);factors.sort_unstable();let mut result=Vec::new();for factor in factors{if let Some((last_factor,exponent))=result.last_mut(){if*last_factor==factor{*exponent+=1;continue;}}result.push((factor,1));}result}fn collect_prime_factors(n:u64,factors:&mut Vec<u64>){if n==1{return;}if is_prime(n){factors.push(n);return;}let divisor=pollard_rho(n);collect_prime_factors(divisor,factors);collect_prime_factors(n/divisor,factors);}fn is_prime(n:u64)->bool{const SMALL_PRIMES:[u64;12]=[2,3,5,7,11,13,17,19,23,29,31,37];if n<2{return false;}for prime in SMALL_PRIMES{if n%prime==0{return n==prime;}}let exponent_of_two=(n-1).trailing_zeros();let odd_part=(n-1)>>exponent_of_two;const BASES:[u64;7]=[2,325,9_375,28_178,450_775,9_780_504,1_795_265_022];'next_base:for base in BASES{let base=base%n;if base==0{continue;}let mut value=mod_pow(base,odd_part,n);if value==1||value==n-1{continue;}for _ in 1..exponent_of_two{value=mod_mul(value,value,n);if value==n-1{continue 'next_base;}}return false;}true}fn pollard_rho(n:u64)->u64{for prime in[2,3,5,7,11,13,17,19,23,29,31,37]{if n%prime==0{return prime;}}let mut random=XorShift64::new(n^0x9e37_79b9_7f4a_7c15);loop{let mut y=random.next()%(n-2)+2;let constant=random.next()%(n-1)+1;let batch_size=128u64;let mut cycle_length=1u64;let mut gcd=1u64;let mut x=0u64;let mut saved_y=0u64;while gcd==1{x=y;for _ in 0..cycle_length{y=polynomial(y,constant,n);}let mut processed=0u64;while processed<cycle_length&&gcd==1{saved_y=y;let count=batch_size.min(cycle_length-processed);let mut product=1u64;for _ in 0..count{y=polynomial(y,constant,n);product=mod_mul(product,x.abs_diff(y),n);}gcd=gcd_u64(product,n);processed+=count;}cycle_length=cycle_length.saturating_mul(2);}if gcd==n{loop{saved_y=polynomial(saved_y,constant,n);gcd=gcd_u64(x.abs_diff(saved_y),n);if gcd>1{break;}}}if gcd!=n{return gcd;}}}fn polynomial(value:u64,constant:u64,modulo:u64)->u64{((value as u128*value as u128+constant as u128)%modulo as u128)as u64}fn mod_mul(lhs:u64,rhs:u64,modulo:u64)->u64{(lhs as u128*rhs as u128%modulo as u128)as u64}fn mod_pow(mut base:u64,mut exponent:u64,modulo:u64)->u64{let mut result=1u64;while exponent>0{if exponent&1==1{result=mod_mul(result,base,modulo);}base=mod_mul(base,base,modulo);exponent>>=1;}result}fn gcd_u64(mut lhs:u64,mut rhs:u64)->u64{while rhs!=0{(lhs,rhs)=(rhs,lhs%rhs);}lhs}struct XorShift64{state:u64,}impl XorShift64{fn new(seed:u64)->Self{Self{state:if seed==0{0x4d59_5df4_d0f3_3173}else{seed},}}fn next(&mut self)->u64{self.state^=self.state<<13;self.state^=self.state>>7;self.state^=self.state<<17;self.state}}}}pub mod utils{#[macro_export]macro_rules!__cargo_equip_macro_def___cp_library_0_1_0_yes_no{($b:expr)=>{$crate::__cargo_equip::crates::__cp_library_0_1_0::yes_no_custom!($b,"Yes","No")};}macro_rules!yes_no{($($tt:tt)*)=>(crate::__cargo_equip_macro_def___cp_library_0_1_0_yes_no!{$($tt)*})}#[macro_export]macro_rules!__cargo_equip_macro_def___cp_library_0_1_0_yes_no_custom{($b:expr,$yes:expr,$no:expr)=>{println!("{}",if$b{$yes}else{$no})};}macro_rules!yes_no_custom{($($tt:tt)*)=>(crate::__cargo_equip_macro_def___cp_library_0_1_0_yes_no_custom!{$($tt)*})}#[must_use]pub const fn yes_no(b:bool)->&'static str{yes_no_custom(b,"Yes","No")}#[must_use]pub const fn yes_no_custom<'a>(b:bool,yes:&'a str,no:&'a str)->&'a str{if b{yes}else{no}}}pub use algorithm::lis;}
        pub mod problems {}
    }

    pub(crate) mod macros {
        pub mod __cp_library_0_1_0 {pub use crate::{__cargo_equip_macro_def___cp_library_0_1_0_yes_no as yes_no,__cargo_equip_macro_def___cp_library_0_1_0_yes_no_custom as yes_no_custom};}
        pub mod problems {}
    }

    pub(crate) mod prelude {pub use crate::__cargo_equip::crates::*;}

    mod preludes {
        pub mod __cp_library_0_1_0 {}
        pub mod problems {pub(in crate::__cargo_equip)use crate::__cargo_equip::crates::__cp_library_0_1_0 as cp_library;}
    }
}