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.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map.Entry;
import java.util.Random;
import java.util.TreeMap;

public class D {

	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int n = Integer.parseInt(br.readLine());

		long arr[] = new long[n];
		String[] parts = br.readLine().split(" ");
		for (int i = 0; i < n; i++) {
			arr[i] = Long.parseLong(parts[i]);
		}

		int res = 0;

		HashMap<Long, Integer> map = new HashMap<Long, Integer>();
		for (int i = 0; i < n; i++) {
			if (!map.containsKey(arr[i]))
				map.put(arr[i], 0);
			map.put(arr[i], map.get(arr[i]) + 1);
		}

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

				long number1 = arr[i];
				long number2 = arr[j];
				int counter = 2;
				
				if (number1==0 && number2==0 && zeroCase==true)
					break;
				if (number1==0 && number2==0)
					zeroCase=true;

				HashMap<Long, Integer> newMap = new HashMap<Long, Integer>();

				if (number1 == number2)
					newMap.put(number1, 2);
				else {
					newMap.put(number1, 1);
					newMap.put(number2, 1);
				}

				while (true) {
					long newNumber = number1 + number2;
					// System.out.println(newNumber);
					Integer upperBound = map.get(newNumber);

					if (upperBound == null) {
						break;
					}
					// System.out.println(upperBound);
					int tek = 0;
					if (newMap.containsKey(newNumber))
						tek = newMap.get(newNumber);

					tek++;
					if (tek > upperBound)
						break;

					// System.out.println(tek);
					newMap.put(newNumber, tek);
					number1 = number2;
					number2 = newNumber;
					counter++;
				}
				// System.out.println(i+" "+j+" "+counter);
				res = Math.max(res, counter);
			}
		}

		System.out.println(res);
	}
}
