You are given n integers a1, a2, ..., an. Find the number of pairs of indexes i, j (i < j) that ai + aj is a power of 2 (i. e. some integer x exists so that ai + aj = 2x).

Input

The first line contains the single positive integer n (1 ≤ n ≤ 105) — the number of integers.

The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109).

Output

Print the number of pairs of indexes i, j (i < j) that ai + aj is a power of 2.

Examples

Input

4
7 3 2 1


Output

2


Input

3
1 1 1


Output

3

Note

In the first example the following pairs of indexes include in answer: (1, 4) and (2, 4).

In the second example all pairs of indexes (i, j) (where i < j) include in answer.
//package cf;
import java.io.*;
import java.util.*;

public final class Cf {
    public static void main(String[] args) throws Exception {
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(java.io.FileDescriptor.out), "ASCII"), 512);        
        FastReader sc = new FastReader();
        int tc=1;
        int n;
        long a[],temp,k,ans;
        k=(long)Math.pow(2,32);
        HashMap<Long,Long>map;
        while(tc-->0)
        {  
          n=sc.nextInt();
          a=new long[n];
          ans=0;
          map=new HashMap<>();
          for(int i=0;i<n;i++)
          {
              a[i]=sc.nextLong();
              map.put(a[i],map.getOrDefault(a[i],0l)+1);
          }
          for(int i=0;i<n;i++)
          {
               temp=2;
               map.put(a[i], map.get(a[i])-1);
              while(temp<k)
              {
                  if(map.containsKey(temp-a[i])&&map.get(temp-a[i])>0)ans+=map.get(temp-a[i]);
                  temp*=2;
              }
          }
          out.write(ans+"\n");

        }
        out.flush();
    }

  public static int go(int a,int b)
  {
      if(a==0)return b;
      return go(b%a,a);
  }
    
    
    public static void debug(String s)
    {
        System.out.println(s);
    }

    ///////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////////////////
    static class FastReader {        
        
        BufferedReader br;        
        StringTokenizer st;        
        
        public FastReader() {            
            br = new BufferedReader(new InputStreamReader(System.in));            
        }        
        
        String next() {            
            while (st == null || !st.hasMoreElements()) {                
                try {                    
                    st = new StringTokenizer(br.readLine());                    
                } catch (IOException e) {                    
                    e.printStackTrace();                    
                }                
            }            
            return st.nextToken();            
        }        
        
        int nextInt() {            
            return Integer.parseInt(next());            
        }        
        
        long nextLong() {            
            return Long.parseLong(next());            
        }        
        
        double nextDouble() {            
            return Double.parseDouble(next());            
        }        
        
        String nextLine() {            
            String str = "";            
            try {                
                str = br.readLine();                
            } catch (IOException e) {                
                e.printStackTrace();                
            }            
            return str;            
        }        
    }
    //////////////////////////////////////////////////////////////////

    static class Reader {        

        final private int BUFFER_SIZE = 1 << 16;        
        private DataInputStream din;        
        private byte[] buffer;        
        private int bufferPointer, bytesRead;        
        
        public Reader() {            
            din = new DataInputStream(System.in);            
            buffer = new byte[BUFFER_SIZE];            
            bufferPointer = bytesRead = 0;            
        }        
        
        public Reader(String file_name) throws IOException {            
            din = new DataInputStream(new FileInputStream(file_name));            
            buffer = new byte[BUFFER_SIZE];            
            bufferPointer = bytesRead = 0;            
        }        
        
        public String readLine() throws IOException {            
            byte[] buf = new byte[1002]; // line length 
            int cnt = 0, c;            
            while ((c = read()) != -1) {                
                if (c == '\n') {
                    break;
                }                
                buf[cnt++] = (byte) c;                
            }            
            return new String(buf, 0, cnt);            
        }        
        
        public int nextInt() throws IOException {            
            int ret = 0;            
            byte c = read();            
            while (c <= ' ') {
                c = read();
            }            
            boolean neg = (c == '-');            
            if (neg) {
                c = read();
            }            
            do {                
                ret = ret * 10 + c - '0';                
            } while ((c = read()) >= '0' && c <= '9');            
            
            if (neg) {
                return -ret;
            }            
            return ret;            
        }        
        
        public long nextLong() throws IOException {            
            long ret = 0;            
            byte c = read();            
            while (c <= ' ') {
                c = read();
            }            
            boolean neg = (c == '-');            
            if (neg) {
                c = read();
            }            
            do {                
                ret = ret * 10 + c - '0';                
            } while ((c = read()) >= '0' && c <= '9');            
            if (neg) {
                return -ret;
            }            
            return ret;            
        }        
        
        public double nextDouble() throws IOException {            
            double ret = 0, div = 1;            
            byte c = read();            
            while (c <= ' ') {
                c = read();
            }            
            boolean neg = (c == '-');            
            if (neg) {
                c = read();
            }            
            
            do {                
                ret = ret * 10 + c - '0';                
            } while ((c = read()) >= '0' && c <= '9');            
            
            if (c == '.') {                
                while ((c = read()) >= '0' && c <= '9') {                    
                    ret += (c - '0') / (div *= 10);                    
                }                
            }            
            
            if (neg) {
                return -ret;
            }            
            return ret;            
        }        
        
        private void fillBuffer() throws IOException {            
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);            
            if (bytesRead == -1) {
                buffer[0] = -1;
            }            
        }        
        
        private byte read() throws IOException {            
            if (bufferPointer == bytesRead) {
                fillBuffer();
            }            
            return buffer[bufferPointer++];            
        }        
        
        public void close() throws IOException {            
            if (din == null) {
                return;
            }            
            din.close();            
        }        
    }    
}
