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
import sys
from math import sqrt, gcd, factorial, ceil, floor, pi, inf
from collections import deque, Counter, OrderedDict
from heapq import heapify, heappush, heappop
#sys.setrecursionlimit(10**6)
#from functools import lru_cache
#@lru_cache(None)

#======================================================#
input = lambda: sys.stdin.readline()
I = lambda: int(input().strip())
S = lambda: input().strip()
M = lambda: map(int,input().strip().split())
L = lambda: list(map(int,input().strip().split()))
#======================================================#

#======================================================#
def primelist():
    L = [False for i in range((10**10)+1)]
    primes = [False for i in range((10**10)+1)]
    for i in range(2,(10**10)+1):
        if not L[i]:
            primes[i]=True
            for j in range(i,(10**10)+1,i):
                L[j]=True
    return primes
def isPrime(n):
    p = primelist()
    return p[n]
#======================================================#
def bst(arr,x):
    low,high = 0,len(arr)-1
    ans = -1
    while low<=high:
        mid = (low+high)//2
        if arr[mid]==x:
            return mid
        elif arr[mid]<x:
            ans = mid
            low = mid+1
        else:
            high = mid-1
    return ans
    
    
def factors(x):
    l1 = []
    l2 = []
    for i in range(1,int(sqrt(x))+1):
        if x%i==0:
            if (i*i)==x:
                l1.append(i)
            else:
                l1.append(i)
                l2.append(x//i)
    for i in range(len(l2)//2):
        l2[i],l2[len(l2)-1-i]=l2[len(l2)-1-i],l2[i]
    return l1+l2
#======================================================#

n = I()
a = L()
P = [2**i for i in range(33)]
d = {}
for i in a:
    if i in d.keys():
        d[i]+=1
    else:
        d[i]=1
ans = 0
for i in a:
    f = True
    for j in P:
        if j-i in d.keys():
            if (j-i)==i:
                if d[j-i]>1:
                    f = False
                    continue
            else:
                f = False
                continue
    if f:
        ans+=1
print(ans)



    
    
    
    
