You are given an array of positive integers a1, a2, ..., an × T of length n × T. We know that for any i > n it is true that ai = ai - n. Find the length of the longest non-decreasing sequence of the given array.

Input

The first line contains two space-separated integers: n, T (1 ≤ n ≤ 100, 1 ≤ T ≤ 107). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 300).

Output

Print a single number — the length of a sought sequence.

Examples

Input

4 3
3 1 4 2


Output

5

Note

The array given in the sample looks like that: 3, 1, 4, 2, 3, 1, 4, 2, 3, 1, 4, 2. The elements in bold form the largest non-decreasing subsequence. 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class D {

	public static void main(String[] args) throws IOException {
		   BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
		    String in = input.readLine();
		    String[] init = in.split(" ");
		    
		    int n = Integer.parseInt(init[0]);
		    int t = Integer.parseInt(init[1]);
		    
		    int[] ni = new int[n];
	    	in = input.readLine();
	    	init = in.split(" ");

		    for(int i = 0; i < n; i ++){
		    	ni[i] = Integer.parseInt(init[i]);
		    }
		    


		    	int z = Math.min(100, t);
			    int[] nx = new int[n * (z + 1)];
			    
			    int min = 0;
			    
			    for(int i = n * z - 1; i >= 0; i--){
				    nx[i] = 1;
			    	for(int j = i + 1; j < n * z; j++){
			    		if(ni[j % n] >= ni[i % n]){
			    			nx[i] = Math.max(nx[i], nx[j] + 1);
			    		}
			    	}
			    }
			    
			    for(int i = 0; i < n * z; i++){
			    	min = Math.max(nx[i], min);
			    }
			    
			    if(t > 100){
			    	z = 101;
			    					    
				    int m2 = 0;
				    
				    for(int i = n * z - 1; i >= 0; i--){
					    nx[i] = 1;
				    	for(int j = i + 1; j < n * z; j++){
				    		if(ni[j % n] >= ni[i % n]){
				    			nx[i] = Math.max(nx[i], nx[j] + 1);
				    		}
				    	}
				    }
				    
				    for(int i = 0; i < n * z; i ++){
				    	m2 = Math.max(nx[i], m2);
				    }
				    
				    System.out.println(min + (long) (m2 - min) * (long) (t - 100) );
			    } else {
				    System.out.println(min);

			    }
		    	

		    
	}
	
}
