A dragon symbolizes wisdom, power and wealth. On Lunar New Year's Day, people model a dragon with bamboo strips and clothes, raise them with rods, and hold the rods high and low to resemble a flying dragon.

A performer holding the rod low is represented by a 1, while one holding it high is represented by a 2. Thus, the line of performers can be represented by a sequence a1, a2, ..., an.

Little Tommy is among them. He would like to choose an interval [l, r] (1 ≤ l ≤ r ≤ n), then reverse al, al + 1, ..., ar so that the length of the longest non-decreasing subsequence of the new sequence is maximum.

A non-decreasing subsequence is a sequence of indices p1, p2, ..., pk, such that p1 < p2 < ... < pk and ap1 ≤ ap2 ≤ ... ≤ apk. The length of the subsequence is k.

Input

The first line contains an integer n (1 ≤ n ≤ 2000), denoting the length of the original sequence.

The second line contains n space-separated integers, describing the original sequence a1, a2, ..., an (1 ≤ ai ≤ 2, i = 1, 2, ..., n).

Output

Print a single integer, which means the maximum possible length of the longest non-decreasing subsequence of the new sequence.

Examples

Input

4
1 2 1 2


Output

4


Input

10
1 1 2 2 2 1 1 2 2 1


Output

9

Note

In the first example, after reversing [2, 3], the array will become [1, 1, 2, 2], where the length of the longest non-decreasing subsequence is 4.

In the second example, after reversing [3, 7], the array will become [1, 1, 1, 1, 2, 2, 2, 2, 2, 1], where the length of the longest non-decreasing subsequence is 9.
import java.io.PrintStream;
import java.util.*;

public class Main {

    public static void main(String[] args) throws Exception {
//        System.setOut(new PrintStream("output.txt"));
        Scanner scanner=new Scanner(System.in);
//        int times=scanner.nextInt();
        int times=1;
        long start=System.currentTimeMillis();
        for (int t=1;t<=times;t++) {
//            System.out.println(String.format("Case #%d: %s", t, new Main().solve(scanner)));
            System.out.println(new Main().solve(scanner));
        }
        long end=System.currentTimeMillis();
        System.err.println(String.format("Time used: %.3fs", (end-start)/1000.0));

    }

    public String solve(Scanner sc) {
        int n = sc.nextInt(), sum=0;
        int[] d = new int[n];
        int[][] dp =  new int[n][n];
        for (int i = 0; i < n; i++) {
            d[i] = sc.nextInt();
            sum+=d[i];
        }
        if(sum==n||sum==2*n) return n+"";
        // all 1s or 2s in range j~i
        for(int i=0; i<n; i++){
            int n1=0, n2=0;
            for(int j=i; j>=0; j--) {
                if(d[j]==1) n1++;
                if(d[j]==2) n2++;
                dp[j][i] = Math.max(n1, n2);
            }
        }
        // reverse range i~j
        for(int k=1; k<n; k++){
            for(int i=0; i<n-k; i++){
                int j=i+k;
                if(k==1) {
                    if(d[i]>=d[j]) dp[i][j]=2;
                    else dp[i][j]=1;
                }else{
                    dp[i][j]=Math.max(dp[i][j], dp[i+1][j-1]+(d[i]==2?1:0)+(d[j]==1?1:0));
                }
            }
        }
        // reverse in range i~j
        for(int k=1; k<n; k++){
            for(int i=0; i<n-k; i++){
                int j=i+k;
                if(k==1) {
                    dp[i][j]=2;
                }else{
                    dp[i][j]=Math.max(dp[i][j], Math.max(dp[i+1][j]+(d[i]==1?1:0), dp[i][j-1]+(d[j]==2?1:0)));
                }
            }
        }
        return dp[0][n-1]+"";
    }




}