#include <bits/stdc++.h>
using namespace std;
int findLongestAP(vector<int>& arr) {
    int n = arr.size();
    if (n == 0) return 1;  
    if (n < 3) return 0;   
    vector<unordered_map<int, int>> dp(n);
    
    int maxLength = 2;  
    for (int j = 1; j < n; j++) {
        for (int i = 0; i < j; i++) {
            int diff = arr[j] - arr[i];  
            if (dp[i].find(diff) != dp[i].end()) {
                dp[j][diff] = dp[i][diff] + 1;
            } else {
                dp[j][diff] = 2;
            }
            
        maxLength = max(maxLength, dp[j][diff]);
        }
    }
    
    return maxLength >= 3 ? maxLength : 0;  
}

int main() {
    int I;
    cin >> I;
    
    vector<int> arr(I);
    for (int i = 0; i < I; i++) {
        cin >> arr[i];
    }
        cout << findLongestAP(arr) << endl;
    
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
class UnionFind {
public:
    vector<int> parent, rank, has_tank;
    
    UnionFind(int n) {
        parent.resize(n);
        rank.resize(n, 0);
        has_tank.resize(n, 0);
        for (int i = 0; i < n; i++) {
            parent[i] = i;
        }
    }
        int find(int x) {
        if (x != parent[x]) {
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }
        void union_sets(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        
        if (rootX != rootY) {
            if (rank[rootX] > rank[rootY]) {
                parent[rootY] = rootX;
                has_tank[rootX] |= has_tank[rootY];  
            } else if (rank[rootX] < rank[rootY]) {
                parent[rootX] = rootY;
                has_tank[rootY] |= has_tank[rootX]; 
            } else {
                parent[rootY] = rootX;
                rank[rootX]++;
                has_tank[rootX] |= has_tank[rootY]; 
            }
        }
    }
        void set_tank(int x) {
        int rootX = find(x);
        has_tank[rootX] = 1;
    }
        bool is_tank(int x) {
        return has_tank[find(x)];
    }
};

int main() {
    int m, n;
    cin >> m >> n; 

    vector<tuple<int, int, int>> edges;  
    for (int i = 0; i < m - 1; i++) {
        int u, v, time;
        cin >> u >> v >> time;
        edges.push_back({time, u, v});
    }

    vector<int> tank_states(n);
    for (int i = 0; i < n; i++) {
        cin >> tank_states[i];
    }
    sort(edges.rbegin(), edges.rend());
    UnionFind uf(m);
    for (int tank : tank_states) {
        uf.set_tank(tank);
    }

    int total_time = 0;
    for (auto& [time, u, v] : edges) {
        if (uf.is_tank(u) && uf.is_tank(v)) {
            total_time += time;
        } else {
            uf.union_sets(u, v);
        }
    }
    cout << total_time << endl;

    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
bool ss(int k, const vector<int>& trees, const vector<int>& sprinklers) {
    int m = sprinklers.size();
    int n = trees.size();
    int i = 0, j = 0;
        while (i < n) {
        if (j < m && trees[i] >= sprinklers[j] - k && trees[i] <= sprinklers[j] + k) {
            i++; 
        } else if (j < m && trees[i] > sprinklers[j] + k) {
            j++; 
        } else {
            return false;  
        }
    }
    
    return true;  
}

int main() {
    int N, M;
    cin >> N;
    vector<int> trees(N);
    for (int i = 0; i < N; i++) {
        cin >> trees[i];
    }
    cin >> M;
    vector<int> sprinklers(M);
    for (int i = 0; i < M; i++) {
        cin >> sprinklers[i];
    }
    sort(trees.begin(), trees.end());
    sort(sprinklers.begin(), sprinklers.end());
        int left = 0;
    int right = max(abs(trees.back() - sprinklers.front()), abs(sprinklers.back() - trees.front()));
    int result = right;
    
    while (left <= right) {
        int mid = (left + right) / 2;
                if (ss(mid, trees, sprinklers)) {
            result = mid; 
            right = mid - 1;
        } else {
            left = mid + 1; 
        }
    }
        cout << result << endl;
    
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int solve(vector<int>& arr, int k) {
    sort(arr.begin(), arr.end());
    int i = 0, j = arr.size() - 1;
    int moves = 0;
    while (i <= j) {
        if (arr[i] + arr[j] <= k) {
            i++;
            j--;
        } else {
            j--;
        }
        moves++; 
    }
    
    return moves;
}