Yash has recently learnt about the Fibonacci sequence and is very excited about it. He calls a sequence Fibonacci-ish if 

  1. the sequence consists of at least two elements 
  2. f0 and f1 are arbitrary 
  3. fn + 2 = fn + 1 + fn for all n ≥ 0. 



You are given some sequence of integers a1, a2, ..., an. Your task is rearrange elements of this sequence in such a way that its longest possible prefix is Fibonacci-ish sequence.

Input

The first line of the input contains a single integer n (2 ≤ n ≤ 1000) — the length of the sequence ai.

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

Output

Print the length of the longest possible Fibonacci-ish prefix of the given sequence after rearrangement.

Examples

Input

3
1 2 -1


Output

3


Input

5
28 35 7 14 21


Output

4

Note

In the first sample, if we rearrange elements of the sequence as  - 1, 2, 1, the whole sequence ai would be Fibonacci-ish.

In the second sample, the optimal way to rearrange elements is <image>, <image>, <image>, <image>, 28.
/**
 * Created by Anna on 13.03.2016.
 */

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.StringTokenizer;

public class TaskD {
    StringTokenizer st;
    PrintWriter out;
    BufferedReader in;

    public static void main(String[] args) throws IOException {
        TaskD solver = new TaskD();
        solver.open();
        solver.solve();
        solver.close();

    }

    private void solve() throws IOException {
        int n = nextInt();
        long[] numbers = new long[n];
        HashMap<Long, Integer> count = new HashMap<>();
        for (int i = 0; i < n; i++) {
            numbers[i] = nextInt();

            int cnt = count.getOrDefault(numbers[i], 0);
            count.put(numbers[i], cnt + 1);
        }

        int maxF = 2;

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (i == j) continue;

                if ((numbers[i] == numbers[j]) && (numbers[j] == 0)) {
                    int cntZero = count.get(0L);
                    maxF = Math.max(cntZero, maxF);
                    continue;
                }

                int curF = 2;

                HashMap<Long, Integer> spent = new HashMap<>();
                long prev = numbers[i];
                long cur = numbers[j];
                if (prev == cur) {
                    spent.put(prev, 2);
                } else {
                    spent.put(prev, 1);
                    spent.put(cur, 1);
                }

                while (true) {
                    long next = prev + cur;
                    final Integer nextSpent = spent.getOrDefault(next, 0);
                    int cntNext = count.getOrDefault(next, 0) - nextSpent;
                    if (cntNext <= 0) break;
                    spent.put(next, nextSpent + 1);
                    curF++;
                    prev = cur;
                    cur = next;
                }

                maxF = Math.max(maxF, curF);

            }
        }

        out.println(maxF);

    }

    private String nextToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            String str = in.readLine();
            if (str == null) return null;
            st = new StringTokenizer(str);
        }
        return st.nextToken();
    }

    private int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }


    private double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }


    private long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    private void close() {
        out.close();
    }

    private void open() {
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
    }
}