#![allow(unused_imports, non_snake_case)]
#![allow(dead_code)]
use crate::{
    arraylist::List, ext::iter::IterExtra, misc::functions::pow, prime_number::prime_factors,
    scanner::Scanner,
};
fn main() {
    let mut scan = Scanner::new();
    let n = scan.read::<i64>();
    let k = scan.read::<i64>();
    let m = scan.read::<i64>();
    let pft = prime_factors(n);
    let pf = pft.iter().list();
    let mut stack = list!();
    stack.push((1i64, 0));
    let mut ret = 0i64;
    while let Some((z, i)) = stack.pop() {
        if i == pf.ilen() {
            ret += 1;
            continue;
        }
        let mut w = z;
        for _ in 0..=pf[i].1 * k {
            stack.push((w, i + 1));
            w *= *pf[i].0;
            if w > m {
                break;
            }
        }
    }
    println!("{}", ret);
}
pub mod independent {
    pub mod integer {
        pub trait Int:
            std::ops::Add<Output = Self>
            + std::ops::Sub<Output = Self>
            + std::ops::Mul<Output = Self>
            + std::ops::Div<Output = Self>
            + std::ops::Rem<Output = Self>
            + std::ops::AddAssign
            + std::ops::SubAssign
            + std::ops::MulAssign
            + std::ops::DivAssign
            + std::hash::Hash
            + PartialEq
            + Eq
            + PartialOrd
            + Ord
            + Copy
        {
            fn to_u8(&self) -> u8;
            fn to_u16(&self) -> u16;
            fn to_u32(&self) -> u32;
            fn to_u64(&self) -> u64;
            fn to_u128(&self) -> u128;
            fn to_i8(&self) -> i8;
            fn to_i16(&self) -> i16;
            fn to_i32(&self) -> i32;
            fn to_i64(&self) -> i64;
            fn to_i128(&self) -> i128;
            fn to_usize(&self) -> usize;
            fn to_isize(&self) -> isize;
            fn from_u8(x: u8) -> Self;
            fn from_u16(x: u16) -> Self;
            fn from_u32(x: u32) -> Self;
            fn from_u64(x: u64) -> Self;
            fn from_u128(x: u128) -> Self;
            fn from_i8(x: i8) -> Self;
            fn from_i16(x: i16) -> Self;
            fn from_i32(x: i32) -> Self;
            fn from_i64(x: i64) -> Self;
            fn from_i128(x: i128) -> Self;
            fn from_usize(x: usize) -> Self;
            fn from_isize(x: isize) -> Self;
            fn zero() -> Self;
            fn one() -> Self;
            fn next(&self) -> Self {
                *self + Self::one()
            }
        }
        macro_rules ! impl_integer_functions { ( $ selftpe : ident , $ ( $ tofn : ident , $ fromfn : ident , $ tpe : ident ) ,* ) => { $ ( fn $ tofn ( & self ) -> $ tpe { * self as $ tpe } fn $ fromfn ( x : $ tpe ) -> Self { x as $ selftpe } ) * } ; }
        macro_rules ! impl_integer { ( $ ( $ tpe : ident ) ,* ) => { $ ( impl Int for $ tpe { impl_integer_functions ! ( $ tpe , to_u8 , from_u8 , u8 , to_u16 , from_u16 , u16 , to_u32 , from_u32 , u32 , to_u64 , from_u64 , u64 , to_u128 , from_u128 , u128 , to_i8 , from_i8 , i8 , to_i16 , from_i16 , i16 , to_i32 , from_i32 , i32 , to_i64 , from_i64 , i64 , to_i128 , from_i128 , i128 , to_usize , from_usize , usize , to_isize , from_isize , isize ) ; fn zero ( ) -> Self { 0 } fn one ( ) -> Self { 1 } } ) * } ; }
        impl_integer!(u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, usize, isize);
    }
}
pub mod misc {
    pub mod functions {
        use crate::arraylist::List;
        use crate::independent::integer::Int;
        use std::collections::{BTreeSet, HashMap};
        pub fn adjacent4(y: i32, x: i32, h: i32, w: i32) -> impl Iterator<Item = (i32, i32)> {
            const DYDX: [(i32, i32); 4] = [(-1, 0), (1, 0), (0, -1), (0, 1)];
            DYDX.iter().filter_map(move |&(dy, dx)| {
                let ny = y + dy;
                let nx = x + dx;
                if nx >= 0 && nx < w && ny >= 0 && ny < h {
                    Some((ny, nx))
                } else {
                    None
                }
            })
        }
        pub fn adjacent8(y: i32, x: i32, h: i32, w: i32) -> impl Iterator<Item = (i32, i32)> {
            const DYDX: [(i32, i32); 8] = [
                (-1, 0),
                (1, 0),
                (0, -1),
                (0, 1),
                (-1, -1),
                (-1, 1),
                (1, -1),
                (1, 1),
            ];
            DYDX.iter().filter_map(move |&(dy, dx)| {
                let ny = y + dy;
                let nx = x + dx;
                if nx >= 0 && nx < w && ny >= 0 && ny < h {
                    Some((ny, nx))
                } else {
                    None
                }
            })
        }
        pub fn run_length_encoding<T: Clone + PartialEq>(slice: &List<T>) -> List<(i64, T)> {
            slice.mrr().fold(List::new(), |mut acc, x| {
                if let Some((cnt, item)) = acc.pop() {
                    if item == x {
                        acc.push((cnt + 1, x));
                    } else {
                        acc.push((cnt, item));
                        acc.push((1, x));
                    }
                } else {
                    acc.push((1, x));
                }
                acc
            })
        }
        pub fn indices_by_elem<T: Eq + std::hash::Hash + Clone>(
            slice: &List<T>,
        ) -> std::collections::HashMap<T, List<i32>> {
            let mut hmap = std::collections::HashMap::new();
            for i in 0..slice.ilen() {
                hmap.entry(slice[i].clone()).or_insert(List::new()).push(i);
            }
            hmap
        }
        pub fn combine<S: Clone, T: Clone, U: std::iter::FromIterator<(S, T)>>(
            left: &[S],
            right: &[T],
        ) -> U {
            let mut ret = vec![];
            for i in 0..left.len() {
                for j in 0..right.len() {
                    ret.push((left[i].clone(), right[j].clone()));
                }
            }
            ret.into_iter().collect::<U>()
        }
        pub fn split<T: PartialEq + Clone>(slice: &List<T>, sep: T) -> List<List<T>> {
            slice
                .iter()
                .fold(List::from(vec![List::new()]), |mut acc, x| {
                    if x == &sep {
                        acc.push(List::new());
                        acc
                    } else {
                        let last = acc.ilen() - 1;
                        acc[last].push(x.clone());
                        acc
                    }
                })
        }
        pub fn coord_comp(slice: &List<i64>) -> (List<i64>, HashMap<i64, i32>) {
            let mut set = BTreeSet::new();
            for &item in slice {
                set.insert(item);
            }
            let mut hmap = HashMap::new();
            for (i, &v) in set.iter().enumerate() {
                hmap.insert(v, i as i32);
            }
            (set.into_iter().collect::<List<_>>(), hmap)
        }
        pub fn shakutori(n: i32, k: i64, a: &List<i64>) -> i32 {
            let mut sum = 0;
            let mut right = 0;
            let mut ret = 0;
            for left in 0..n {
                while right < n && sum <= k {
                    sum += a[right];
                    right += 1;
                }
                ret += right - left;
                if right == left {
                    right += 1;
                } else {
                    sum -= a[left];
                }
            }
            ret
        }
        pub fn inverse(a: &List<i32>, n: i32) -> List<i32> {
            let mut inv = List::init(0, n);
            for i in 0..a.ilen() {
                inv[a[i]] = i;
            }
            inv
        }
        pub fn pow(mut a: i64, mut n: i64) -> i64 {
            let mut res = 1;
            while n > 0 {
                if n & 1 == 1 {
                    res *= a;
                }
                a = a * a;
                n >>= 1;
            }
            res
        }
        pub fn ceil_div<T: Int>(x: T, y: T) -> T {
            (x + y - T::one()) / y
        }
        pub fn ceil_mod<T: Int>(x: T, y: T) -> T {
            ceil_div(x, y) * y
        }
        pub fn is_palindrome<T: Clone + Eq>(chars: &List<T>) -> bool {
            let s = chars.clone();
            let mut t = s.clone();
            t.reverse();
            (0..s.ilen()).filter(|&i| s[i] == t[i]).count() as i32 == s.ilen()
        }
    }
}
pub mod arraylist {
    use crate::{ext::range::IntRangeBounds, independent::integer::Int};
    use std::fmt::Formatter;
    use std::iter::FromIterator;
    use std::ops::{Index, IndexMut, RangeBounds};
    use std::slice::Iter;
    #[derive(Clone, PartialEq, Eq)]
    pub struct List<T> {
        pub vec: Vec<T>,
    }
    impl<T> List<T> {
        #[inline]
        pub fn new() -> List<T> {
            List { vec: vec![] }
        }
        #[inline]
        pub fn init(init: T, n: i32) -> List<T>
        where
            T: Clone,
        {
            List {
                vec: vec![init; n as usize],
            }
        }
        #[inline]
        pub fn from_vec(vec: Vec<T>) -> List<T> {
            List { vec }
        }
        #[inline]
        pub fn acc<'a, S>(n: i32, mut f: S) -> List<T>
        where
            S: FnMut(i32) -> T + 'a,
        {
            (0..n).map(|i| f(i)).collect()
        }
        #[inline]
        pub fn ilen(&self) -> i32 {
            self.vec.len() as i32
        }
        #[inline]
        pub fn iter(&self) -> Iter<'_, T> {
            self.vec.iter()
        }
        #[inline]
        pub fn push(&mut self, item: T) {
            self.vec.push(item);
        }
        #[inline]
        pub fn sort(&mut self)
        where
            T: Ord,
        {
            self.vec.sort();
        }
        #[inline]
        pub fn reverse(&mut self) {
            self.vec.reverse();
        }
        #[inline]
        pub fn sort_by<F>(&mut self, compare: F)
        where
            F: FnMut(&T, &T) -> std::cmp::Ordering,
        {
            self.vec.sort_by(compare)
        }
        #[inline]
        pub fn sort_by_key<K, F>(&mut self, compare: F)
        where
            F: FnMut(&T) -> K,
            K: Ord,
        {
            self.vec.sort_by_key(compare)
        }
        #[inline]
        pub fn first(&self) -> Option<&T> {
            self.vec.first()
        }
        #[inline]
        pub fn last(&self) -> Option<&T> {
            self.vec.last()
        }
        #[inline]
        pub fn pop(&mut self) -> Option<T> {
            self.vec.pop()
        }
        #[inline]
        pub fn swap(&mut self, i: i32, j: i32) {
            self.vec.swap(i as usize, j as usize);
        }
        #[inline]
        pub fn append(&mut self, mut other: Self) {
            self.vec.append(&mut other.vec);
        }
        #[inline]
        pub fn extend(&mut self, other: impl Iterator<Item = T>) {
            self.vec.extend(other);
        }
        #[inline]
        pub fn mrr(&self) -> std::iter::Cloned<Iter<T>>
        where
            T: Clone,
        {
            self.iter().cloned()
        }
        #[inline]
        pub fn join(&self, sep: &str) -> String
        where
            T: std::fmt::Display,
        {
            self.iter()
                .map(|x| format!("{}", x))
                .collect::<Vec<_>>()
                .join(sep)
        }
        #[inline]
        pub fn map<B, F>(&self, f: F) -> List<B>
        where
            T: Clone,
            F: FnMut(T) -> B,
        {
            self.mrr().map(f).collect()
        }
        #[inline]
        pub fn filter<P>(&self, predicate: P) -> List<T>
        where
            T: Clone,
            P: FnMut(&T) -> bool,
        {
            self.mrr().filter(predicate).collect()
        }
        #[inline]
        pub fn filter_map<B, F>(&self, f: F) -> List<B>
        where
            T: Clone,
            F: FnMut(T) -> Option<B>,
        {
            self.mrr().filter_map(f).collect()
        }
        #[doc = " |acc, x| -> acc"]
        #[inline]
        pub fn fold<B, F>(&self, init: B, f: F) -> B
        where
            T: Clone,
            F: FnMut(B, T) -> B,
        {
            self.mrr().fold(init, f)
        }
        #[inline]
        pub fn any<P>(&self, predicate: P) -> bool
        where
            P: FnMut(&T) -> bool,
        {
            self.iter().any(predicate)
        }
        #[inline]
        pub fn all<P>(&self, predicate: P) -> bool
        where
            P: FnMut(&T) -> bool,
        {
            self.iter().all(predicate)
        }
        #[inline]
        pub fn sum(&self) -> T
        where
            T: Int,
        {
            self.iter().cloned().fold(T::zero(), |acc, x| acc + x)
        }
        #[inline]
        pub fn enumerate(&self) -> List<(i32, T)>
        where
            T: Clone,
        {
            self.mrr().enumerate().map(|p| (p.0 as i32, p.1)).collect()
        }
        #[inline]
        pub fn find<P>(&self, mut predicate: P) -> Option<&T>
        where
            P: FnMut(&T) -> bool,
        {
            self.iter().find(|x| predicate(*x))
        }
        #[inline]
        pub fn index_of<P>(&self, mut predicate: P) -> Option<i32>
        where
            P: FnMut(&T) -> bool,
        {
            self.iter()
                .enumerate()
                .find(|&(_i, x)| predicate(x))
                .map(|p| p.0 as i32)
        }
        #[inline]
        pub fn to<B: FromIterator<T>>(&self) -> B
        where
            T: Clone,
        {
            self.mrr().collect()
        }
        #[inline]
        pub fn min(&self) -> Option<&T>
        where
            T: Ord,
        {
            self.iter().min()
        }
        #[inline]
        pub fn max(&self) -> Option<&T>
        where
            T: Ord,
        {
            self.iter().max()
        }
        #[inline]
        pub fn argmin(&self) -> Option<i32>
        where
            T: Ord,
        {
            let item = self.iter().min()?;
            self.iter()
                .enumerate()
                .find(|p| p.1 == item)
                .map(|p| p.0 as i32)
        }
        #[inline]
        pub fn argmax(&self) -> Option<i32>
        where
            T: Ord,
        {
            let item = self.iter().max()?;
            self.iter()
                .enumerate()
                .find(|p| p.1 == item)
                .map(|p| p.0 as i32)
        }
        #[inline]
        pub fn part<U>(&self, range: U) -> List<T>
        where
            T: Clone,
            U: RangeBounds<i32>,
        {
            List::from_vec(
                self.vec[range.lower_bound(0) as usize..range.upper_bound(self.ilen()) as usize]
                    .to_vec(),
            )
        }
        #[inline]
        pub fn first_exn(&self) -> &T {
            self.first().unwrap()
        }
        #[inline]
        pub fn last_exn(&self) -> &T {
            self.last().unwrap()
        }
        #[inline]
        pub fn pop_exn(&mut self) -> T {
            self.pop().unwrap()
        }
        #[inline]
        pub fn min_exn(&self) -> &T
        where
            T: Ord,
        {
            self.min().unwrap()
        }
        #[inline]
        pub fn max_exn(&self) -> &T
        where
            T: Ord,
        {
            self.max().unwrap()
        }
        #[inline]
        pub fn argmin_exn(&self) -> i32
        where
            T: Ord,
        {
            self.argmin().unwrap()
        }
        #[inline]
        pub fn argmax_exn(&self) -> i32
        where
            T: Ord,
        {
            self.argmax().unwrap()
        }
        #[inline]
        pub fn find_exn<P>(&self, predicate: P) -> &T
        where
            P: FnMut(&T) -> bool,
        {
            self.find(predicate).unwrap()
        }
        #[inline]
        pub fn index_of_exn<P>(&self, predicate: P) -> i32
        where
            P: FnMut(&T) -> bool,
        {
            self.index_of(predicate).unwrap()
        }
    }
    impl<T> std::ops::BitXorAssign<T> for List<T> {
        #[inline]
        fn bitxor_assign(&mut self, rhs: T) {
            self.push(rhs);
        }
    }
    impl<T> Index<i32> for List<T> {
        type Output = T;
        #[inline]
        fn index(&self, index: i32) -> &Self::Output {
            if cfg!(debug_assertions) {
                self.vec.index(index as usize)
            } else {
                unsafe { self.vec.get_unchecked(index as usize) }
            }
        }
    }
    impl<T> IndexMut<i32> for List<T> {
        #[inline]
        fn index_mut(&mut self, index: i32) -> &mut Self::Output {
            if cfg!(debug_assertions) {
                self.vec.index_mut(index as usize)
            } else {
                unsafe { self.vec.get_unchecked_mut(index as usize) }
            }
        }
    }
    impl<T> FromIterator<T> for List<T> {
        fn from_iter<U: IntoIterator<Item = T>>(iter: U) -> Self {
            List {
                vec: iter.into_iter().collect(),
            }
        }
    }
    impl<T> IntoIterator for List<T> {
        type Item = T;
        type IntoIter = std::vec::IntoIter<T>;
        fn into_iter(self) -> std::vec::IntoIter<T> {
            self.vec.into_iter()
        }
    }
    impl<'a, T> IntoIterator for &'a List<T> {
        type Item = &'a T;
        type IntoIter = Iter<'a, T>;
        fn into_iter(self) -> Iter<'a, T> {
            self.vec.iter()
        }
    }
    impl<T: std::fmt::Display> std::fmt::Display for List<T> {
        fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
            write!(
                f,
                "{}",
                self.iter()
                    .map(|x| format!("{}", x))
                    .collect::<Vec<_>>()
                    .join(" ")
            )
        }
    }
    impl<T: std::fmt::Debug> std::fmt::Debug for List<T> {
        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
            write!(
                f,
                "[{}]",
                self.iter()
                    .map(|x| format!("{:?}", x))
                    .collect::<Vec<_>>()
                    .join(", ")
            )
        }
    }
    impl<T> From<Vec<T>> for List<T> {
        fn from(vec: Vec<T>) -> Self {
            Self::from_vec(vec)
        }
    }
    impl<T: Clone> From<&[T]> for List<T> {
        fn from(slice: &[T]) -> Self {
            slice.iter().cloned().collect()
        }
    }
    #[macro_export]
    macro_rules ! list { ( ) => { $ crate :: arraylist :: List :: new ( ) } ; ( $ ( $ v : expr ) ,+ $ ( , ) ? ) => { $ crate :: arraylist :: List :: from_vec ( [ $ ( $ v ) ,+ ] . to_vec ( ) ) } ; ( $ v : expr ; $ a : expr ) => { $ crate :: arraylist :: List :: init ( $ v , $ a ) } ; ( $ v : expr ; $ a : expr ; $ ( $ rest : expr ) ;+ ) => { $ crate :: arraylist :: List :: init ( list ! ( $ v ; $ ( $ rest ) ;+ ) , $ a ) } ; }
}
pub mod data_structure {
    pub mod counter {
        use std::collections::HashMap;
        use std::hash::Hash;
        use std::ops::*;
        #[derive(Clone, Debug)]
        pub struct Counter<K: Eq + Hash> {
            pub cnt: HashMap<K, i64>,
            pub d: i64,
        }
        impl<K: Eq + Hash> Counter<K> {
            pub fn new() -> Counter<K> {
                Counter {
                    cnt: HashMap::new(),
                    d: 0,
                }
            }
            #[doc = " Remove key when the value <= 0"]
            pub fn dec(&mut self, key: K, delta: i64) {
                if self.by_ref(&key) - delta <= 0 {
                    self.remove(&key);
                } else {
                    *self.cnt.get_mut(&key).unwrap() -= delta;
                }
            }
            pub fn by_ref(&self, key: &K) -> i64 {
                *self.cnt.get(key).unwrap_or(&self.d)
            }
        }
        impl<K: Eq + Hash> Deref for Counter<K> {
            type Target = HashMap<K, i64>;
            fn deref(&self) -> &Self::Target {
                &self.cnt
            }
        }
        impl<K: Eq + Hash> DerefMut for Counter<K> {
            fn deref_mut(&mut self) -> &mut Self::Target {
                &mut self.cnt
            }
        }
        impl<K: Eq + Hash> Index<K> for Counter<K> {
            type Output = i64;
            fn index(&self, index: K) -> &Self::Output {
                self.cnt.get(&index).unwrap_or(&self.d)
            }
        }
        impl<K: Eq + Hash + Clone> IndexMut<K> for Counter<K> {
            fn index_mut(&mut self, index: K) -> &mut i64 {
                if !self.cnt.contains_key(&index) {
                    self.cnt.insert(index.clone(), self.d);
                }
                self.cnt.get_mut(&index).unwrap()
            }
        }
        impl<K: Eq + Hash> std::iter::FromIterator<K> for Counter<K> {
            fn from_iter<T: IntoIterator<Item = K>>(iter: T) -> Self {
                let mut cnt = HashMap::new();
                for i in iter {
                    *cnt.entry(i).or_insert(0) += 1;
                }
                Counter { cnt, d: 0 }
            }
        }
        impl<T: Eq + Hash + Clone> Add for Counter<T> {
            type Output = Counter<T>;
            fn add(self, other: Counter<T>) -> Counter<T> {
                let mut ret = Counter::new();
                for (k, v) in self.iter().chain(other.iter()) {
                    ret[k.clone()] += *v;
                }
                ret
            }
        }
        impl<T: Eq + Hash + Clone> AddAssign for Counter<T> {
            fn add_assign(&mut self, other: Self) {
                *self = self.clone().add(other);
            }
        }
    }
}
pub mod ext {
    pub mod range {
        use crate::independent::integer::Int;
        use std::cmp::{max, min};
        use std::ops::{Bound, Range, RangeBounds};
        pub trait IntRangeBounds<U: Int>: RangeBounds<U> {
            fn lbopt(&self) -> Option<U> {
                match self.start_bound() {
                    Bound::Included(x) => Some(*x),
                    Bound::Excluded(x) => Some(*x + U::one()),
                    Bound::Unbounded => None,
                }
            }
            fn ubopt(&self) -> Option<U> {
                match self.end_bound() {
                    Bound::Included(x) => Some(*x + U::one()),
                    Bound::Excluded(x) => Some(*x),
                    Bound::Unbounded => None,
                }
            }
            #[doc = " inclusive"]
            fn lower_bound(&self, limit: U) -> U {
                self.lbopt().map_or(limit, |x| max(limit, x))
            }
            #[doc = " exclusive"]
            fn upper_bound(&self, limit: U) -> U {
                self.ubopt().map_or(limit, |x| min(limit, x))
            }
            fn to_harfopen(&self, lb: U, ub: U) -> Range<U> {
                self.lower_bound(lb)..self.upper_bound(ub)
            }
            fn width(&self) -> U {
                if self.empty() {
                    U::zero()
                } else {
                    self.ubopt().unwrap() - self.lbopt().unwrap()
                }
            }
            fn empty(&self) -> bool {
                self.lbopt().is_none()
                    || self.ubopt().is_none()
                    || !(self.lbopt().unwrap() < self.ubopt().unwrap())
            }
            fn contain_range(&self, inner: &Self) -> bool {
                (match (self.lbopt(), inner.lbopt()) {
                    (Some(a), Some(b)) => a <= b,
                    (None, _) => true,
                    (Some(_), None) => false,
                }) && (match (inner.ubopt(), self.ubopt()) {
                    (Some(a), Some(b)) => a <= b,
                    (_, None) => true,
                    (None, Some(_)) => false,
                })
            }
            fn separate_range(&self, other: &Self) -> bool {
                if let (Some(a), Some(b)) = (self.ubopt(), other.lbopt()) {
                    if a <= b {
                        return true;
                    }
                }
                if let (Some(a), Some(b)) = (other.ubopt(), self.lbopt()) {
                    if a <= b {
                        return true;
                    }
                }
                false
            }
            fn overlap(&self, other: &Self) -> Range<U> {
                let left = if let (Some(a), Some(b)) = (self.lbopt(), other.lbopt()) {
                    max(a, b)
                } else {
                    self.lbopt().or(other.lbopt()).unwrap()
                };
                let right = if let (Some(a), Some(b)) = (self.ubopt(), other.ubopt()) {
                    min(a, b)
                } else {
                    self.ubopt().or(other.ubopt()).unwrap()
                };
                left..right
            }
        }
        impl<T: ?Sized, U: Int> IntRangeBounds<U> for T where T: RangeBounds<U> {}
    }
    pub mod iter {
        use crate::{arraylist::List, independent::integer::Int};
        pub trait IterExtra: Iterator + Sized {
            fn list(self) -> List<Self::Item> {
                self.collect()
            }
            fn to<B: std::iter::FromIterator<Self::Item>>(self) -> B {
                self.collect()
            }
            fn counti(self) -> i32 {
                self.count() as i32
            }
            fn enumeratei(
                self,
            ) -> std::iter::Map<
                std::iter::Enumerate<Self>,
                fn((usize, Self::Item)) -> (i32, Self::Item),
            > {
                self.enumerate().map(|t| (t.0 as i32, t.1))
            }
            fn sumint(self) -> Self::Item
            where
                Self::Item: Int,
            {
                self.fold(Self::Item::zero(), |acc, x| acc + x)
            }
            fn min_exn(self) -> Self::Item
            where
                Self::Item: Ord,
            {
                self.min().unwrap()
            }
            fn max_exn(self) -> Self::Item
            where
                Self::Item: Ord,
            {
                self.max().unwrap()
            }
        }
        impl<T> IterExtra for T where T: Iterator {}
    }
}
pub mod scanner {
    use crate::arraylist::List;
    use std::io::{stdin, BufReader, Bytes, Read, Stdin};
    use std::str::FromStr;
    macro_rules ! impl_readxn { ( $ name : ident , $ ( $ tpe : ident ) ,+ ) => { pub fn $ name <$ ( $ tpe : FromStr ) ,+> ( & mut self , n : i32 ) -> List < ( $ ( $ tpe ) ,+ ) > { ( 0 .. n ) . map ( | _ | ( $ ( self . read ::<$ tpe > ( ) ) ,+ ) ) . collect ( ) } } ; }
    pub struct Scanner {
        buf: Bytes<BufReader<Stdin>>,
    }
    impl Scanner {
        pub fn new() -> Scanner {
            Scanner {
                buf: BufReader::new(stdin()).bytes(),
            }
        }
        pub fn read_next<T: FromStr>(&mut self) -> Option<T> {
            let token = self
                .buf
                .by_ref()
                .map(|c| c.unwrap() as char)
                .skip_while(|c| c.is_whitespace())
                .take_while(|c| !c.is_whitespace())
                .collect::<String>();
            token.parse::<T>().ok()
        }
        pub fn read<T: FromStr>(&mut self) -> T {
            self.read_next().unwrap()
        }
        pub fn readn<T: FromStr>(&mut self, n: i32) -> List<T> {
            (0..n).map(|_| self.read::<T>()).collect()
        }
        pub fn chars(&mut self) -> List<char> {
            self.read::<String>().chars().collect()
        }
        impl_readxn!(read2n, P, Q);
        impl_readxn!(read3n, P, Q, R);
        impl_readxn!(read4n, P, Q, R, S);
        impl_readxn!(read5n, P, Q, R, S, T);
    }
}
pub mod prime_number {
    use crate::arraylist::List;
    use crate::data_structure::counter::Counter;
    pub fn is_prime(n: i64) -> bool {
        for i in (2..).take_while(|i| i * i <= n) {
            if n % i == 0 {
                return false;
            }
        }
        n != 1
    }
    pub fn divisors(n: i64) -> List<i64> {
        let mut ret = List::new();
        for i in (1..).take_while(|i| i * i <= n) {
            if n % i == 0 {
                ret.push(i);
                if i != n / i {
                    ret.push(n / i);
                }
            }
        }
        ret
    }
    pub fn prime_factors(n_: i64) -> Counter<i64> {
        let mut ret = Counter::new();
        let n = std::cell::Cell::new(n_);
        for i in (2..).take_while(|&i| i * i <= n.get()) {
            while n.get() % i == 0 {
                ret[i] += 1;
                n.set(n.get() / i);
            }
        }
        if n.get() != 1 {
            ret[n.get()] = 1;
        }
        ret
    }
    pub fn sieve(n: i32) -> (List<i32>, List<bool>) {
        let mut primes = List::new();
        let mut is_prime = List::init(true, n + 1);
        is_prime[0] = false;
        is_prime[1] = false;
        for i in 2..n + 1 {
            if is_prime[i] {
                primes.push(i);
                for j in (2..).map(|j| j * i).take_while(|&j| j <= n) {
                    is_prime[j] = false;
                }
            }
        }
        (primes, is_prime)
    }
}