Problem:
Score : 400 points

Problem Statement

Given is a number sequence A of length N.

Find the number of integers i \left(1 \leq i \leq N\right) with the following property:

For every integer j \left(1 \leq j \leq N\right) such that i \neq j , A_j does not divide A_i.

Constraints

All values in input are integers.

1 \leq N \leq 2 \times 10^5

1 \leq A_i \leq 10^6

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 \cdots A_N

Output

Print the answer.

Sample Input 1

5
24 11 8 3 16

Sample Output 1

3

The integers with the property are 2, 3, and 4.

Sample Input 2

4
5 5 5 5

Sample Output 2

0

Note that there can be multiple equal numbers.

Sample Input 3

10
33 18 45 28 8 19 89 86 2 4

Sample Output 3

5

Solution in Rust (1.42.0) (judge verdict: Wrong Answer)

#![allow(unused_macros)]
#![allow(dead_code)]
#![allow(unused_imports)]

use text_io::*;

fn main() {
    let n: usize = read!();
    let mut a = vec![];
    for _ in 0..n {
        let p: usize = read!();
        a.push(p);
    }

    a.sort();

    if a[0] == 1 {
        println!("{}", 1);
        std::process::exit(0);
    }

    let end_len = a.len();
    let mut ng = vec![false; n];

    for (k, &i) in a.iter().enumerate() {
        'child: for j in 1..=5000000 {
            let start = a.lower_bound(|&m| m >= i * j);
            let end = a.lower_bound(|&m| m > i * j);
            if start == end_len {
                break;
            } else {
                for l in start..end {
                    if a[l] % i != 0 {
                        break 'child;
                    } else if l != k {
                        ng[l] = true;
                    }
                }
            }
        }
    }

    println!("{}", ng.iter().filter(|&&m| !m).count());
}

trait BinarySearch<T> {
    fn lower_bound<F>(&self, f: F) -> usize
    where
        F: Fn(&T) -> bool;
}
impl<T> BinarySearch<T> for [T] {
    fn lower_bound<F>(&self, f: F) -> usize
    where
        F: Fn(&T) -> bool,
    {
        let mut left: isize = -1;
        let mut right = self.len() as isize;
        while right - left > 1 {
            let mid = (left + right) / 2;
            if f(&self[mid as usize]) {
                right = mid;
            } else {
                left = mid;
            }
        }
        right as usize
    }
}