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 Go (1.14.1) (judge verdict: Wrong Answer)

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

var sc = bufio.NewReaderSize(os.Stdin, 1024*1024*10)

func main() {
	N := getStdinInt64()
	A := getStdinIntArr64()
	//B := make([][]int64, N)
	var i int64 = 0
	var j int64 = 0
	var cnt int64 = 0
	var max int64 = 0

	for _, val := range A {
		if val > max {
			max = val
		}
	}

	/*
		//arr := make([]bool, int(math.Sqrt(float64(max)))+1)
		arr := make([]bool, int((float64(max)))+1)
		// 初期化
		// 素数を求める(falseが素数)
		arr[0] = true
		arr[1] = true
		for i := 2; i < len(arr); i++ {
			if arr[i] {
				for j := i * 2; j < len(arr); j += i {
					arr[j] = true
				}
			}
		}*/

	/*
		for i = 0; i< N ; i++ {
			B[i] = make([]int64, N)
		}
	*/

	for i = 0; i < N; i++ {
		flag := true
		flag2 := true
		for j = 0; j < N; j++ {
			if i == j {
				continue
			}
			if A[i] == A[j] {
				flag2 = false
				break
			}
			if A[j] == 1 {
				flag = false
				break
			}
		}
		if !flag2 {
			continue
		}
		if !flag {
			cnt++
			continue
		}
		/*
			if arr[A[i]] == false {
				cnt++
				continue
			}
		*/
		flag = true
		for j = 0; j < N; j++ {
			if i == j {
				continue
			}
			if A[i]%A[j] == 0 {
				flag = false
				break
			}
		}
		if flag {
			cnt++
		}
	}

	fmt.Printf("%d\n", cnt)
}

func getStdin() string {
	return readLine()
}
func getStdinInt() int {
	str := getStdin()
	rtn, _ := strconv.Atoi(str)
	return rtn
}
func getStdinInt64() int64 {
	str := getStdin()
	rtn, _ := strconv.ParseInt(str, 10, 64)
	return rtn
}
func getStdinIntArr() []int {
	str := getStdin()
	list := strings.Split(str, " ")
	rtn := make([]int, len(list))
	for idx, val := range list {
		rtn[idx], _ = strconv.Atoi(val)
	}
	return rtn
}

func getStdinIntArr64() []int64 {
	str := getStdin()
	list := strings.Split(str, " ")
	rtn := make([]int64, len(list))
	for idx, val := range list {
		rtn[idx], _ = strconv.ParseInt(val, 10, 64)
	}
	return rtn
}

func readLine() string {
	buf := make([]byte, 0, 0)
	for {
		l, p, e := sc.ReadLine()
		if e != nil {
			panic(e)
		}
		buf = append(buf, l...)
		if !p {
			break
		}
	}
	return string(buf)
}