#ifdef _DEBUG
#ifdef _SORAIE
#define _GLIBCXX_DEBUG
#endif
#endif

#include <bits/stdc++.h>

#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")

using namespace std;
//--------------------------------------------------------------------
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define overload4(_1,_2,_3,_4,name,...) name
#define rep1(n) for(ll _ThiS_WoNt_Be_usEd=0;_ThiS_WoNt_Be_usEd<(ll)n;++_ThiS_WoNt_Be_usEd)
#define rep2(i,n) for(ll i=0;i<(ll)n;++i)
#define rep3(i,a,b) for(ll i=(ll)a;i<(ll)b;++i)
#define rep4(i,a,b,c) for(ll i=(ll)a;i<(ll)b;i+=(ll)c)
#define rep(...) overload4(__VA_ARGS__,rep4,rep3,rep2,rep1)(__VA_ARGS__)

#if defined(_SORAIE) && defined(_DEBUG)

#include <debug.hpp>

#else

#define debug(...) void(0);
#define koko void(0);
#define pass(...) void(0);

#endif

#define mp make_pair
#define ten(d) int64_t(1e##d)
struct asdfghjkl{asdfghjkl(){ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);}} qwertyuiop;
void doset(int n){cout << fixed << setprecision(n);cerr << fixed << setprecision(n);}
using ll = long long;
using ld = long double;
using dou = double;
constexpr int inf = 1 << 30;
constexpr ll INF = 1LL << 61;
constexpr ld pi = 3.14159265358;
constexpr ll mod1 = 1000000007LL;
constexpr ll mod2 = 998244353LL;
using pll = pair<ll,ll>;
using pli = pair<ll,int>;
using pii = pair<int,int>;
template<class T, class U> inline bool chmin(T& a, const U& b){ if(a > b){ a = b; return 1; } return 0; }
template<class T, class U> inline bool chmax(T& a, const U& b){ if(a < b){ a = b; return 1; } return 0; }
ll modpow(ll n,ll m,ll MOD){
    if(m == 0)return 1;
    if(m < 0)return 0;
    ll res = 1;
    n %= MOD;
    while(m){
        if(m & 1)res = (res * n) % MOD;
        m >>= 1;
        n *= n;
        n %= MOD;
    }
    return res;
}
ll mypow(ll n,ll m){
    if(m == 0)return 1;
    if(m < 0)return -1;
    ll res = 1;
    while(m){
        if(m & 1)res = (res * n);
        m >>= 1;
        n *= n;
    }
    return res;
}

inline bool isp(ll n){
    bool res = true;
    if(n == 1 || n == 0)return false;
    else{
        for(ll i = 2;i * i <= n;i++){
            if(n % i == 0){
                res = false;
                break;
            }
        }
        return res;
    }
}
inline bool Yes(bool b = 1){cout << (b ? "Yes\n":"No\n");return b;}
inline bool YES(bool b = 1){cout << (b ? "YES\n":"NO\n");return b;}
map<ll,ll> primefactor(ll n){
    map<ll,ll> ma;
    if(n <= 1)return ma;
    ll m = n;
    for(ll i = 2;i * i <= n;i++){
        while(m % i == 0){
            ma[i]++;
            m /= i;
        }
    }
    if(m != 1)ma[m]++;
    return ma;
}
vector<ll> divisor(ll n,bool sorted = true,bool samein = false){
    vector<ll> res;
    for(ll i = 1;i * i <= n;i++){
        if(n % i == 0){
            res.push_back(i);
            if(i * i != n || samein)res.push_back(n / i);
        }
    }
    if(sorted)sort(all(res));
    return res;
}

ll __lcm(ll a,ll b){return a / __gcd(a,b) * b;}

template<class T>T sum(const vector<T> &V){T r=0;for(auto x:V)r+=x;return r;}
template<class T>T sum(const initializer_list<T> &V){T r=0;for(auto x:V)r+=x;return r;}


#if __has_include("atcoder/all")
#include <atcoder/all>
using namespace atcoder;
template<int m,class OS>
OS& operator<<(OS& os,const static_modint<m>& self){os << self.val();return os;}
#endif

// #include <boost/multiprecision/cpp_dec_float.hpp>
// using lld = boost::multiprecision::number<boost::multiprecision::cpp_dec_float<20>>;

// #include <boost/multiprecision/cpp_int.hpp>
// using lll = boost::multiprecision::cpp_int;

//--------------------------------------------------------------------

int op(int a,int b){return max(a,b);}
int e(){return 0;}

int main(){
    int N;
    cin >> N;
    vector<int> vec(N);
    rep(i,N)cin >> vec[i];
    vector<int> za = vec;
    sort(all(za));
    za.erase(unique(all(za)),za.end());
    rep(i,N)vec[i] = lower_bound(all(za),vec[i]) - za.begin();
    int ans = 0;
    debug(vec);
    {
        // 0..N
        segtree<int,op,e> st(N + 1);
        vector<int> memo(N);
        rep(i,N){
            memo[i] = st.prod(0,vec[i]) + 1;
            st.set(vec[i],max(st.get(vec[i]),memo[i]));
        }
        debug(memo);
        vector<int> rmemo(N);
        segtree<int,op,e> rst(N + 1);
        for(int i = N - 1;i >= 0;i--){
            rmemo[i] = rst.prod(0,vec[i]) + 1;
            rst.set(vec[i],max(rst.get(vec[i]),rmemo[i]));
        }
        debug(rmemo);
        int cnt = 0;
        rep(i,N)chmax(cnt,min(memo[i],rmemo[i]) - 1);

        chmax(ans,cnt);
    }
    {
        // 0..N
        segtree<int,op,e> st(N + 1);
        vector<int> memo(N);
        rep(i,N){
            debug(vec[i] + 1,N);
            memo[i] = st.prod(vec[i] + 1,N) + 1;
            st.set(vec[i],max(st.get(vec[i]),memo[i]));
        }
        debug(memo);
        vector<int> rmemo(N);
        segtree<int,op,e> rst(N + 1);
        for(int i = N - 1;i >= 0;i--){
            debug(vec[i] + 1,N);
            rmemo[i] = rst.prod(vec[i] + 1,N) + 1;
            rst.set(vec[i],max(rst.get(vec[i]),rmemo[i]));
        }
        debug(rmemo);
        int cnt = 0;
        rep(i,N)chmax(cnt,min(memo[i],rmemo[i]) - 1);

        chmax(ans,cnt);
    }
    cout << ans << "\n";
}