Petya was late for the lesson too. The teacher gave him an additional task. For some array *a* Petya should find the number of different ways to select non-empty subset of elements from it in such a way that their product is equal to a square of some integer.

Two ways are considered different if sets of indexes of elements chosen by these ways are different.

Since the answer can be very large, you should find the answer modulo 10<sup class="upper-index">9</sup> + 7.
First line contains one integer *n* (1 ≤ *n* ≤ 10<sup class="upper-index">5</sup>) — the number of elements in the array.

Second line contains *n* integers *a*<sub class="lower-index">*i*</sub> (1 ≤ *a*<sub class="lower-index">*i*</sub> ≤ 70) — the elements of the array.
In first sample product of elements chosen by any way is 1 and 1 = 1<sup class="upper-index">2</sup>. So the answer is 2<sup class="upper-index">4</sup> - 1 = 15.

In second sample there are six different ways to choose elements so that their product is 4, and only one way so that their product is 16. So the answer is 6 + 1 = 7.
4
1 1 1 1
15
4
2 2 2 2
7
5
1 2 4 5 8
7
1
64
1
5
2 2 2 2 2
15
6
1 2 3 4 5 6
7
2
70 70
1
7
4 9 16 25 36 49 64
127
13
64 65 40 26 36 46 53 31 63 11 2 46 59
15
15
66 34 43 45 61 14 12 67 38 25 55 9 30 41 16
15
17
44 57 54 57 54 65 40 57 59 16 39 51 32 51 20 9 8
511
18
22 41 40 8 36 48 23 5 58 12 26 44 53 49 3 56 58 57
127
20
20 34 51 40 70 64 14 30 24 20 6 1 70 28 38 43 9 60 31 69
2047
5
19 51 55 29 13
0
6
19 60 48 64 56 27
3
7
67 52 58 62 38 26 2
1
7
5 28 46 57 39 26 45
1
7
53 59 56 9 13 1 28
3
10
38 58 51 41 61 12 17 47 18 24
3
10
27 44 40 3 33 38 56 37 43 36
7
10
51 4 25 46 15 21 32 9 43 8
15
10
5 66 19 60 34 27 15 27 42 51
7
5
2 3 5 7 11
0
10
2 3 5 7 11 13 17 19 23 29
0
2
15 45
0
"""

La solución de referencia utiliza una técnica de programación dinámica para resolver el problema.

1) Se define una lista de números primos y una función de conversión conv(num) 
que toma un número entero como entrada y devuelve un entero en formato de máscara de bits. 
La máscara de bits representa si un número primo en la lista de primos es un divisor del número dado. 
Por ejemplo, si el número dado es 6, que es divisible por 2 y 3, la máscara de bits será 110.

2) La función checkXor(mask) verifica si un número en formato de máscara de bits puede ser representado como un XOR de las máscaras de bits en la lista basis. Si es así, devuelve True, de lo contrario devuelve False.

3) La función insert(mask) intenta insertar un número en formato de máscara de bits en la lista basis.
Si se inserta con éxito, incrementa la variable global sz en 1.

4) Después de definir estas funciones, el programa lee la entrada y convierte cada 
número en la secuencia dada en su representación de máscara de bits utilizando la función conv(). 
Luego, intenta insertar cada máscara de bits en la lista basis utilizando la función insert().

5) Finalmente, el programa calcula la cantidad de subsecuencias 
no vacías cuyo producto es un cuadrado perfecto utilizando la fórmula poten[N - sz] - 1. 
Aquí, poten es una lista de potencias de 2 módulo MOD, que se utiliza para calcular 
el resultado rápidamente.

El resultado se imprime en la salida.


"""



MOD = 1000000007
basis = [0] * 20
sz = 0
primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67]
def conv(num):
	ret = 0
	for i in range(len(primes)):
		while num % (primes[i] * primes[i]) == 0:
			num //= primes[i] * primes[i]
		ret += (1 << i) * (num % primes[i] == 0)
	return ret
def checkXor(mask):
	for i in range(20):
		if mask & (1 << i):
			continue
		if basis[i] == 0:
			return False
		mask ^= basis[i]
	return True
def insert(mask):
	global sz
	for i in range(20):
		if mask & (1 << i) == 0:
			continue
		if basis[i] == 0:
			basis[i] = mask;
			sz += 1
			return
		mask ^= basis[i]
N = int(input())
arr = list(map(int, input().split()))
poten = [0] * (N + 10)
poten[0] = 1
for i in range(1, N + 5):
	poten[i] = poten[i - 1] * 2
	poten[i] %= MOD
for i in range(N):
	arr[i] = conv(arr[i])
	insert(arr[i])
print(poten[N - sz] - 1)

