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()]
b=[]
c=[False]*n
out=0
for i in range (32):
    x=2**i
    b.append(x)
a.sort()
#binarysearch

for i in range (1,32):
    if((b[i]-a[len(a)-1])>a[len(a)-1]):
        break
    if(b[i]>a[0]):
        for k in range (n):
            if (a[k] >= b[i]):
                break
            if (c[k]==True):
                continue
            else:
                x=b[i]-a[k]
                l=0
                r=n-1
                check=False
                while(l<=r):
                    #print(l,r,mid)
                    mid=int((l+r)/2)
                    if(a[mid]==x):
                        check=True
                        break
                    elif (a[mid]<x):
                        l=mid+1
                    else:
                        r=mid-1
                #print(b[i],a[k],x,check)
                if(check==True):
                    if(x!=a[k]):
                        c[k]=True
                    else:
                        if(len(a)==1):
                            c[k]=False
                        elif(k==0):
                            if(a[k+1]==a[k]):
                                c[k]=True
                        elif (k==n-1):
                            if(a[k-1]==a[k]):
                                c[k]=True
                        else:
                            if(a[k-1]==a[k] or a[k+1]==a[k]):
                                c[k]=True
for i in range(n):
    if c[i]==False:
        out+=1
print(out)