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 JavaScript (Node.js 12.16.1) (judge verdict: Time Limit Exceeded)

function Main(input) {
    input = input.trim().split("\n").map(function(x) { return x.split(" ")});
    var N = parseInt(input[0],10);
    var vec_A = input[1].map(e => parseInt(e, 10));   
    var vec_ans = [];
    var X, groupL, groupH, searchTableL, searchTableH;
    var aryMax = function (a, b) {return Math.max(a, b);}
	if (vec_A.indexOf(1) !== -1) {
		 vec_A = vec_A.filter(function (x, i, self) {
            return self.indexOf(x) === i && i === self.lastIndexOf(x);
        });
        if (vec_A.indexOf(1) === -1) {
        	vec_ans = [];
        } else {
			vec_ans = [1];
		}
	} else {
		while (true){
			if (vec_A.length == 1) {
				vec_ans.push(vec_A[0]);
				break;
			}  else if (vec_A.length < 1){
				break;
			} else {
				X = Math.sqrt(vec_A.reduce(aryMax));
				groupL = vec_A.filter( function( value ) {
					return value <= X;
					})
				searchTableL = groupL.reduce(function(m, a, i) {
					m[a] = (m[a] || []).concat(i);
					return m;
					}, {});
				groupH = vec_A.filter( function( value ) {
					return value > X;
					})
				searchTableH = groupH.reduce(function(m, a, i) {
					m[a] = (m[a] || []).concat(i);
					return m;
					}, {});
				for (var i = 0; i < groupH.length; i++){
					divisionCheck_loop:	
					for (var j = 2; j <= X; j++){
						if (groupH[i] % j == 0){
							if((j in searchTableL) || ((groupH[i]/j) in searchTableH)) break divisionCheck_loop;
						}
						if (j == Math.floor(X)) vec_ans.push(groupH[i]);
					}
				}
			}
				vec_A = groupL.slice();
		}
	}
    
    vec_ans = vec_ans.filter(function (x, i, self) {
            return self.indexOf(x) === i && i === self.lastIndexOf(x);
        });
	console.log(vec_ans.length);
}   

Main(require("fs").readFileSync("/dev/stdin", "utf8"));