Problem:
Score : 600 points

Problem Statement

Takahashi has N balls with positive integers written on them. The integer written on the i-th ball is A_i.
He would like to form some number of pairs such that the sum of the integers written on each pair of balls is a power of 2.
Note that a ball cannot belong to multiple pairs.
Find the maximum possible number of pairs that can be formed.

Here, a positive integer is said to be a power of 2 when it can be written as 2^t using some non-negative integer t.

Constraints

1 \leq N \leq 2\times 10^5

1 \leq A_i \leq 10^9

A_i is an integer.

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 ... A_N

Output

Print the maximum possible number of pairs such that the sum of the integers written on each pair of balls is a power of 2.

Sample Input 1

3
1 2 3

Sample Output 1

1

We can form one pair whose sum of the written numbers is 4 by pairing the first and third balls.
Note that we cannot pair the second ball with itself.

Sample Input 2

5
3 11 14 5 13

Sample Output 2

2

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include "bits/stdc++.h"
using namespace std;
///////////////////////////////////////////
const long long int INF = 1LL<<60;
const long long int Mod = 1000000007;
using ll = long long int; using ci = const int;
using vi = vector<int>;  using Vi = vector<long long int>;
using P = pair<int, int>;  using PLL = pair<ll, ll>;
using matrix = vector<vector<ll>>;
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define all(x) (x).begin(),(x).end()
#define rep(i,N) for(ll i = 0; i < (ll)N; i++)
#define repi(i,a,b) for(ll i = ll(a); i < ll(b); ++i)
template<class T>bool chmax(T &former, const T &b) { if (former<b) { former=b; return true; } return false; }
template<class T>bool chmin(T &former, const T &b) { if (b<former) { former=b; return true; } return false; }
template<class T>T sqar(T x){ return x*x; }//sqrt(x)は平方根;
#define Sort(v) std::sort(v.begin(), v.end(), std::greater<decltype(v[0])>()) //降順でVをソート
#define p_queue(v) priority_queue<v, vector<v>, greater<v> >
template<class T> inline void princ(T x){cout<<x<<" ";}; 
template<class T> inline void print(T x){cout<<x<<"\n";};
template<class T> inline void Yes(T condition){ if(condition) cout << "Yes" << endl; else cout << "No" << endl; }
template<class T> inline void YES(T condition){ if(condition) cout << "YES" << endl; else cout << "NO" << endl; }
///////////////////////////////////////////////////////////////////////////////////

ll n;
Vi a;

int main(){
	cin.tie(0);ios::sync_with_stdio(false);
	std::cout<<std::fixed<<std::setprecision(30);
	cin>>n;
	a.resize(n);
	map<ll,ll> ma;
	rep(i,n){
		cin>>a[i];
		ma[a[i]]++;
	}
	sort(all(a));
	ll mx = a[a.size()-1] + a[a.size()-2];
	ll idt = 1;
	Vi tws;
	while(idt<mx){
		idt *= 2;
		tws.pb(idt);
	}
	matrix ctn(n);
	rep(i,n){
		if(ma[a[i]]<=0)continue;
		ll id = upper_bound(all(tws),a[i]) - tws.begin();
		repi(j,id,tws.size()){
			if(ma[tws[j]-a[i]]>0){
				if(tws[j]==a[i]*2){
					if(ma[a[i]]>=2)rep(k,ma[tws[j]-a[i]])ctn[i].pb(tws[j]-a[i]);
				}else{
					rep(k,ma[tws[j]-a[i]])ctn[i].pb(tws[j]-a[i]);
				}
			}
		}
	}
	vector<pair<ll,PLL>> vp(n);
	rep(i,n){
		vp[i] = mp(ctn[i].size(),mp(a[i],i));
	}
	sort(all(vp));
	ll ans = 0;
	rep(i,n){
		ll id = vp[i].second.second;
		if(ma[a[id]]<0)continue;
		rep(j,ctn[id].size()){
			ll now = ctn[id][j];
			if(ma[now]>0){
				if(now==a[id]){
					if(ma[now]<2)continue;
					ans++;
					ma[now]-=2;
				}
				ans += 1;
				ma[now]--;
				ma[a[id]]--;
			}
		}
	}
	print(ans);
	return 0;
}