You are given a string S of length n with each character being one of the first m lowercase English letters. 

Calculate how many different strings T of length n composed from the first m lowercase English letters exist such that the length of LCS (longest common subsequence) between S and T is n - 1.

Recall that LCS of two strings S and T is the longest string C such that C both in S and T as a subsequence.

Input

The first line contains two numbers n and m denoting the length of string S and number of first English lowercase characters forming the character set for strings (1 ≤ n ≤ 100 000, 2 ≤ m ≤ 26).

The second line contains string S.

Output

Print the only line containing the answer.

Examples

Input

3 3
aaa


Output

6


Input

3 3
aab


Output

11


Input

1 2
a


Output

1


Input

10 9
abacadefgh


Output

789

Note

For the first sample, the 6 possible strings T are: aab, aac, aba, aca, baa, caa. 

For the second sample, the 11 possible strings T are: aaa, aac, aba, abb, abc, aca, acb, baa, bab, caa, cab.

For the third sample, the only possible string T is b.
import java.util.*;
import java.io.*;
public class LCSAgain
{
	public static void main(String[] args) throws Exception
	{
		FastScanner in = new FastScanner(System.in);
		
		int n = in.nextInt();
		int m = in.nextInt();
		
		String s = in.next();
		int[] str = new int[n];
		for(int x = 0; x < n; x++)
		{
			str[x] = s.charAt(x) - 'a';
		}
		
		long[][] sum = new long[2][n + 1];
		for(int y = str.length - 1; y >= 0; y--)
		{
			sum[0][y] = sum[0][y + 1];
			sum[1][y] = sum[1][y + 1];
			
			if(y > 0 && str[y - 1] != str[y])
			{
				sum[0][y]++;
			}
			
			sum[1][y] += m - 1;
		}
		
		long result = 0;
		for(int z = 0; z < str.length; z++)
		{
			result += m - 1;
			result += (m - 1) * sum[0][z + 1];
			if(z < str.length - 1 && str[z + 1] != str[z])
			{
				result += sum[1][z + 1];
			}
		}
		
		int ch = str[0];
		int other = -1;
		int size = 1;
		for(int a = 1; a < str.length; a++)
		{
			if(str[a] == ch)
			{
				size = 1;
			}
			else if(str[a] == other)
			{
				size++;
			}
			else
			{
				size = 2;
			}
			
			result -= size - 1;
			
			other = ch;
			ch = str[a];
		}
		
		System.out.println(result);
	}
	
	static class FastScanner
	{
		BufferedReader br;
		StringTokenizer st;
		
		public FastScanner(InputStream input)
		{
			br = new BufferedReader(new InputStreamReader(input));
			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());
		}
	}
}
