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 <cstddef>
#include <iostream>
#include <iomanip>
#include <string>
#include <sstream>
#include <vector>
#include <array>
#include <unordered_map>
#include <algorithm>
#include <numeric>
#include <limits>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <bitset>
#include <valarray>
#include <utility>
#include <tuple>
#include <cmath>
#include <memory>
#include <random>
#include <fstream>
#include <locale>

using ll = long long;
using ull = unsigned long long;

//vector
template <class T>
using vec = std::vector<T>;

template <class T>
using vvec = vec<vec<T>>;

constexpr std::size_t operator""_sz(ull n) { return std::size_t(n); }

int main()
{
    using namespace std;

    int n;
    cin >> n;
    vec<int> v(n);
    vec<bool> used(n);
    set<ll> se;

    vec<ll> pow2(32);
    pow2[0] = 1;
    for (int i = 1; i < 32; ++i)
    {
        pow2[i] = pow2[i - 1] * 2;
    }

    for (auto &e : v)
    {
        cin >> e;
        se.emplace(e);
    }

    sort(v.begin(), v.end());

    int ans{};

    for (int i = n - 1; i >= 0; --i)
    {
        if (used[i])
            continue;

        auto target = *upper_bound(pow2.cbegin(), pow2.cend(), v[i]);

        auto find = se.find(target - v[i]);

        if (find != se.end() && target != v[i])
        {
            auto val = *find;
            se.erase(val);

            auto index = distance(v.begin(), upper_bound(v.begin(), v.end(), val));
            used[index] = true;
            used[i] = true;
            ++ans;
        }
    }

    cout << ans << endl;

    return 0;
}