//Hoang1264589
#include "bits/stdc++.h"
#define Task "TRIANGLE"
#define up(i,a,b) for (int i = (int)a; i <= (int)b; i++)
#define pii pair<int, int>
#define f first
#define s second
#define ep emplace_back
#define bit(x,i) ((x >> i) & 1)
using namespace std;

const int maxn = 1e5 + 10;
int a[maxn];
int n;

int spmax[17][maxn];
int spmin[17][maxn];
int tmin[17][maxn];
namespace Sub4{
    bool compare_max(int x, int y){ return a[x] > a[y]; }
    bool compare_min(int x, int y){ return a[x] < a[y]; }

    void make_sparse(){
        up(i,1,n){
            spmax[0][i] = spmin[0][i] = i;
            tmin[0][i] = 0;
        }
        for (int i = 1; (1 << i) <= n; i++){
            for (int j = 1; j + (1 << i) - 1 <= n; j++){
                if (compare_max(spmax[i-1][j], spmax[i-1][j + (1 << (i-1))])){
                    spmax[i][j] = spmax[i-1][j];
                }
                else spmax[i][j] = spmax[i-1][j + (1 << (i-1))];

                int Lm = spmin[i-1][j];
                int Rm = spmin[i-1][j + (1 << (i-1))];
                int Lt = tmin[i-1][j];
                int Rt = tmin[i-1][j + (1 << (i-1))];

                if (compare_min(Lm, Rm)) spmin[i][j] = Lm;
                else spmin[i][j] = Rm;

                vector<int> temp = {};
                temp.ep(Lm), temp.ep(Rm), temp.ep(Lt), temp.ep(Rt);
                sort(temp.begin(), temp.end(), compare_min);
                tmin[i][j] = temp[1];
            }
        }
    }

    int querymax(int L, int R){
        int k = 31 - __builtin_clz(R - L + 1);
        if (compare_max(spmax[k][L], spmax[k][R - (1 << k) + 1])){
            return spmax[k][L];
        }
        return spmax[k][R - (1 << k) + 1];
    }
    pii querymin(int L, int R){
        int k = 31 - __builtin_clz(R - L + 1);
        const int& Lmin = spmin[k][L];
        const int& Rmin = spmin[k][R - (1 << k) + 1];

        int len = R - L + 1;
        vector<int> save;
        up(i,0,16){
            if (bit(len, i)){
                save.ep(spmin[i][L]);
                save.ep(tmin[i][L]);
                L += (1 << i);
            }
        }
        sort(save.begin(), save.end(), compare_min);
        if (compare_min(Lmin, Rmin)) return make_pair(Lmin, save[1]);
        return make_pair(Rmin, save[1]);
    }

    bool check_longest(int len){
        up(l,1,n){
            int r = l+len;
            if (r > n) break;
            int MaxEle = querymax(l, r);
            pii MinEle = querymin(l, r);
            if (a[MinEle.f] + a[MinEle.s] > a[MaxEle]) return true;
        }
        return false;
    }

    void MAIN(){
        make_sparse();
        int L = 0;
        int R = n+1;
        while (R - L > 1){
            int mid = (R+L) >> 1;
            if (check_longest(mid)) L = mid;
            else R = mid;
        }
        cout << R;
    }
}

namespace Sub3{
    void MAIN(){
        int l = 1;
        int r = 3;
        int maxx = 0;
        while (r != n){
            if (r - l <= 2) ++r;
            else if (a[l] + a[l+1] > a[r]){
                maxx = max(maxx, r - l + 1);
                ++r;
            }
            else ++l;
        }
        if (a[l] + a[l+1] > a[r]) maxx = max(maxx, r - l + 1);
        cout << maxx;
    }
}

signed main(){
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    if (fopen(Task".inp", "r")){
        freopen (Task".inp", "r", stdin);
        freopen (Task".out", "w", stdout);
    }

    bool sorted = 1;
    cin >> n;
    up(i,1,n){
        cin >> a[i];
        if (i > 1 && a[i] < a[i-1]) sorted = 0;
    }
    a[0] = 1e9 + 7;

    if (sorted) Sub3::MAIN();
    else Sub4::MAIN();
}