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: Runtime Error)

fn get_line() -> String {
    let mut line = String::new();
    std::io::stdin().read_line(&mut line).unwrap();
    line.trim().to_string()
}

fn main() {
    let _ = get_line();

    let mut aas: Vec<i64> = get_line()
        .split_whitespace()
        .map(|e| e.parse().unwrap())
        .collect();
    aas.sort();
    let mut count = 0;

    for i in 0..aas.len() {
        let mut result = true;
        if i != 0 && i != aas.len() - 1 {
            if aas[i - 1] == aas[i] || aas[i] == aas[i + 1] {
                continue;
            }
        } else if i == 0 {
            if aas[i] == aas[i + 1] {
                continue;
            }
        } else if i == aas.len() - 1 {
            if aas[i - 1] == aas[i] {
                continue;
            }
        }
        for j in 0..i {
            if aas[i] % aas[j] == 0 {
                result = false;
                break;
            }
        }
        if result {
            count += 1;
        }
    }
    println!("{}", count);
}