#include <iostream>
#include <vector>

using namespace std;

short N = 10;

void sortuj(short* tab)
{
    for(short i = 0; i < N; ++i)
        for(short j = 0; j < N - i - 1; ++j)
            if(tab[j] < tab[j + 1])
                swap(tab[j], tab[j + 1]);
}

bool trojkat(vector<short> kombo, short* tablica)
{
    if(tablica[kombo[0]] - tablica[kombo[1]] <= tablica[kombo[2]])
        return true;
    return false;
}

bool kombinacja(vector<short>& nastepny, vector<short> poprzedni, short maksymalny)
{
    if(poprzedni[2] < maksymalny)
    {
        nastepny[0] = poprzedni[0];
        nastepny[1] = poprzedni[1];
        nastepny[2] = poprzedni[2] + 1;
        return true;
    }
    if(poprzedni[1] < poprzedni[2] - 1)
    {
        nastepny[0] = poprzedni[0];
        nastepny[1] = poprzedni[1] + 1;
        nastepny[2] = nastepny[1] + 1;
        if(nastepny[2] > maksymalny)
            return false;
        return true;
    }
    if(poprzedni[0] < poprzedni[1] - 1)
    {
        nastepny[0] = poprzedni[0] + 1;
        nastepny[1] = nastepny[0] + 1;
        nastepny[2] = nastepny[1] + 1;
        if(nastepny[2] > maksymalny)
            return false;
        return true;
    }
    return false;
}

vector<vector<short>> wszystkie_kombinacje(short min, short max)
{
    vector<short> kombo;
    kombo.resize(3);
    kombo[0] = min;
    kombo[1] = min + 1;
    kombo[2] = min + 2;
    vector<short> nowy;
    nowy.resize(3);

    vector<vector<short>> kombinacje;
    kombinacje.push_back(kombo);
    short i = 0;
    while(kombinacja(nowy, kombinacje[i], max))
    {
        kombinacje.push_back(nowy);
        ++i;
    }
    return kombinacje;
}

bool czy_dziala(short min, short max, short* tablica)
{
    vector<vector<short>> kombinacje = wszystkie_kombinacje(min, max);
    unsigned ile = kombinacje.size();

    for(unsigned i = 0; i < ile; ++i)
        if(!trojkat(kombinacje[i], tablica))
            return false;
    return true;
}

int main()
{
    cin >> N;
    short tablica[N];
    for(short i = 0; i < N; ++i)
        cin >> tablica[i];
    sortuj(tablica);

    short max = 0;

    for(short i = 0; i < N - 2; ++i)
        for(short j = i + 2; j < N; ++j)
        {
            if(j - i + 1 <= max)
                continue;
            if(czy_dziala(i, j, tablica))
                max = j - i + 1;
        }

    cout << max;

    return 0;
}