A sequence $a_1, a_2, \dots, a_n$ is called good if, for each element $a_i$, there exists an element $a_j$ ($i \ne j$) such that $a_i+a_j$ is a power of two (that is, $2^d$ for some non-negative integer $d$).

For example, the following sequences are good:
 -  $[5, 3, 11]$ (for example, for $a_1=5$ we can choose $a_2=3$. Note that their sum is a power of two. Similarly, such an element can be found for $a_2$ and $a_3$), -  $[1, 1, 1, 1023]$, -  $[7, 39, 89, 25, 89]$, -  $[]$. 
Note that, by definition, an empty sequence (with a length of $0$) is good.

For example, the following sequences are not good:
 -  $[16]$ (for $a_1=16$, it is impossible to find another element $a_j$ such that their sum is a power of two), -  $[4, 16]$ (for $a_1=4$, it is impossible to find another element $a_j$ such that their sum is a power of two), -  $[1, 3, 2, 8, 8, 8]$ (for $a_3=2$, it is impossible to find another element $a_j$ such that their sum is a power of two). 
You are given a sequence $a_1, a_2, \dots, a_n$. What is the minimum number of elements you need to remove to make it good? You can delete an arbitrary set of elements.
The first line contains the integer $n$ ($1 \le n \le 120000$) — the length of the given sequence.

The second line contains the sequence of integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^9$).
6
4 7 1 5 4 9
1
5
1 2 3 4 5
2
1
16
1
4
1 1 1 1023
0
10
2 10 9 1 10 4 7 8 5 4
5
2
1 1
0
2
1 6
2
6
1 7 7 7 7 7
0
3
1 2 3
1
3
1 3 3
0
2
3 3
2
2
3 1
0
3
1 2 2
1
2
2 2
0
2
2 1
2
3
1 1 3
0
3
1 3 2
1
3
1 1 2
1
1
1
1
# n = int(input())
# A = [int(x) for x in input().split()]
# PT = [1]
# for i in range(24):
#     PT.append(2*PT[len(PT)-1])
# Ok = set()
# N = set()
# A2 = set(A)
# rn = 0
# for i in A2:
#     if i in N or i in Ok: continue
#     cur = False
#     T = False
#     if A.count(i) > 1: T = True
#     for k in PT:
#         if k-i == i and not T: continue
#         if k-i > max(A2): break
#         if k-i < min(A2): continue
#         if k-i in A2:
#             cur = True
#             Ok.add(i)
#             Ok.add(k-i)
#             break
#     if not cur:
#         N.add(i)
#         rn += A.count(i)

# for i in range(n):
#     if A[i] in Ok or A[i] in N: continue
#     cur = False
#     for k in range(n):
#         if k != i:
#             if A[k] in N: continue
#             if A[i]+A[k] in PT:
#                 cur = True
#                 Ok.add(A[i])
#                 Ok.add(A[k])
#     if not cur:
#         N.add(A[i])
#         rn += A.count(A[i])

n = int(input())
A = [int(x) for x in input().split()]
PT = [2**x for x in range(32)]
PT.reverse()
As = set(A)
Y = set()
rn = 0
for i in As:
    cur = False
    if i in Y: continue
    for j in PT:
        if j <= i: break
        if j - i in As:
            if j - i == i and A.count(i) == 1: continue
            Y.add(j - i)
            cur = True
    if not cur:
        rn += A.count(i)
print(rn)