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)

use std::io;
use std::thread;
use std::sync::{Arc, Mutex};
use std::time::Duration;
 
fn readint() -> Vec<i32> {
  let mut s = String::new();
  io::stdin().read_line(&mut s);
  s.trim().split_whitespace().map(|x| x.parse::<i32>().unwrap()).collect()
}

fn main() {
  let _ = readint();
  let re = readint();
  let le = re.len();
  let b = Arc::new(re);
  let ans = Arc::new(Mutex::new(0_i64));
  let mut handles = Vec::new();
  for i in 0..le {
    let bb = b.clone();
    let aa = ans.clone();
    let handle = thread::spawn(move || {
      let mut suc = true;
      for (k, l) in bb.iter().enumerate() {
        if bb[i] % l == 0 && k != i {
          suc = false;
          break;
        }
      }
      if suc == true {
        let mut an = aa.lock().unwrap();
        *an += 1;
      }
    });
    handles.push(handle);
  }
  for i in handles {
    i.join().unwrap();
  }
  let aaa = ans.lock().unwrap();
  println!("{}", aaa);
}