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.util.*;
import java.lang.*;
import java.io.*;

public class Solution
{
    	public static void main (String[] args) throws java.lang.Exception
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(System.out);
		StringTokenizer st = new StringTokenizer(br.readLine());
		
		int n = Integer.parseInt(st.nextToken());
		int t = Integer.parseInt(st.nextToken());
		int[] bit = new int[301];
		int[] count = new int[301];
		int max = 0;
		
		st = new StringTokenizer(br.readLine());
		int[] in = new int[n];
		for(int i=0;i<n;i++){
		   in[i] = Integer.parseInt(st.nextToken());
		   count[in[i]]++;
		   max = Math.max(max,count[in[i]]);
		} 
		
		int blocks = Math.min(10000/n,t);
		
		int[] a = new int[n*blocks];
		for(int i=0;i<n*blocks;i++) a[i] = in[i%n];
		int ans = 0;
		for(int val:a)
		ans = Math.max(binaryIndexedTree(bit,val),ans);
		
		out.println(ans+max*(t-blocks));
		out.close();
	}
	
	public static int binaryIndexedTree(int[] bit, int val){
	    int res = 0;
	    int value = val;
	    
	    while(val > 0){
	        res= Math.max(bit[val],res);
	        val -= (-val)&val;
	    }
	    
	    res++;
	    val = value;

	    while(val<bit.length){
	        bit[val] = Math.max(bit[val],res);
	        val+=(-val)&val;
	    }
	    return res;
	}
}