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.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class a {

	public static void main(String[] args) throws IOException {
		FastScanner in = new FastScanner(System.in);
		int n = in.nextInt();
		int numbers[] = new int[n];
		for(int i = 0; i < n; i++)
			numbers[i] = in.nextInt();
		
		int runningOnes[] = new int[n];
		for(int i = 0; i < n; i++) {
			if(numbers[i] != 1) {
				continue;
			}
			if(i != 0) {
				runningOnes[i] += runningOnes[i-1];
			}
			runningOnes[i]++;
		}
		int runningTwos[] = new int[n];
		for(int i = 0; i < n; i++) {
			if(numbers[i] != 2) {
				continue;
			}
			if(i != 0) {
				runningTwos[i] += runningTwos[i-1];
			}
			runningTwos[i]++;
		}
		
		int best;
		int ro[] = new int[n];
		int rt[] = new int[n];
		for(int i = 0; i < n; i++) {
			if(numbers[i] == 1) ro[i]++;
			if(i != 0) ro[i] += ro[i-1];
			if(numbers[i] == 2) rt[i]++;
			if(i != 0) rt[i] += rt[i-1];
		}
		best = rt[n-1];
		best = Math.max(ro[n-1], best);
		int a[][] = new int[n][n];
		for(int i = 0; i < n; i++) {
	        for(int j = i; j < n; j++) {
	           if(i == j) a[i][j] = 1;
	           else {
	        	   if(numbers[j] == 1) {
	        		   a[i][j] = a[i][j-1]+1;
	        	   } else {
	        		   a[i][j] = Math.max(a[i][j-1], rt[j] - (i==0?0:rt[i-1]));
	        	   }
	           }
	        }
		}
		
		for(int i = 0; i < n; i++) {
			for(int j = i; j < n; j++) {
				int temp = 0;
				if(i > 0) temp += ro[i-1];
				if(j > 0) temp += rt[n-1] - rt[j];
				temp += a[i][j];
				best = Math.max(best, temp); 
			}
		}

		System.out.println(best);
		
	}
	
	
	
	static class FastScanner {
	    BufferedReader br;
	    StringTokenizer st;
		
	    public FastScanner(InputStream i) {
	        br = new BufferedReader(new InputStreamReader(i));
	        st = new StringTokenizer("");
	    }
				
	    public String next() throws IOException {
	        if(st.hasMoreTokens())
	            return st.nextToken();
	        else
	            st = new StringTokenizer(br.readLine());
	        return next();
	    }

	    public int nextInt() throws IOException {
	        return Integer.parseInt(next());
	    }
	    //#
	    public long nextLong() throws IOException {
	        return Long.parseLong(next());
	    }
	    public double nextDouble() throws IOException {
	        return Double.parseDouble(next());
	    }
	    //$
	}
}
