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.util.*;
import java.io.*;
import java.math.*;

public class Main {

	static class FastScanner {
		BufferedReader s;
		StringTokenizer st;

		public FastScanner(InputStream InputStream) {
			st = new StringTokenizer("");
			s = new BufferedReader(new InputStreamReader(InputStream));
		}

		public FastScanner(File f) throws FileNotFoundException {
			st = new StringTokenizer("");
			s = new BufferedReader(new FileReader(f));
		}

		public int nextInt() throws IOException {
			if (st.hasMoreTokens())
				return Integer.parseInt(st.nextToken());
			else {
				st = new StringTokenizer(s.readLine());
				return nextInt();
			}
		}

		public BigInteger big() throws IOException {
			if (st.hasMoreTokens())
				return new BigInteger(st.nextToken());
			else {
				st = new StringTokenizer(s.readLine());
				return big();
			}
		}

		public double nextDouble() throws IOException {
			if (st.hasMoreTokens())
				return Double.parseDouble(st.nextToken());
			else {
				st = new StringTokenizer(s.readLine());
				return nextDouble();
			}
		}

		public long nextLong() throws IOException {
			if (st.hasMoreTokens())
				return Long.parseLong(st.nextToken());
			else {
				st = new StringTokenizer(s.readLine());
				return nextLong();
			}
		}

		public String next() throws IOException {
			if (st.hasMoreTokens())
				return st.nextToken();
			else {
				st = new StringTokenizer(s.readLine());
				return next();
			}

		}

		public String nextLine() throws IOException {
			return s.readLine();
		}

		public void close() throws IOException {
			s.close();
		}

	}

	public static void main(String[] args) throws java.lang.Exception {
		FastScanner in = new FastScanner(System.in);
		int n = in.nextInt();
		long arr[] = new long[n];
		HashMap<Long, Integer> map = new HashMap();
		for(int x = 0; x < n; x++) {
			arr[x] = in.nextLong();
			map.put(arr[x], map.getOrDefault(arr[x], 0) + 1);
		}
		int ans = 2;
		for(int x = 0; x < n; x++) {
			for(int y = 0; y < n; y++) {
				if(x == y || (arr[x] == arr[y] && y < x)) continue;
				long f1 = arr[x];
				long f2 = arr[x] + arr[y];
				int len = 2;
				if(f1 == 0 && f2 == 0) {
					ans = Math.max(ans, map.get(0l));
					continue;
				}
				ArrayList<Long> used = new ArrayList();
				used.add(arr[x]);
				used.add(arr[y]);
				map.put(arr[x], map.get(arr[x]) - 1);
				map.put(arr[y], map.get(arr[y]) - 1);
				while(map.containsKey(f2) && map.get(f2) > 0) {
					used.add( f2);
					map.put(f2, map.get(f2) - 1);
					long temp = f1 + f2;
					f1 = f2;
					f2 = temp;
					len++;
				}
				for(long ele : used)
					map.put(ele, map.get(ele) + 1);
				ans = Math.max(ans, len);
			}
		}
		System.out.println(ans);
	}
}
