Natasha is going to fly to Mars. She needs to build a rocket, which consists of several stages in some order. Each of the stages is defined by a lowercase Latin letter. This way, the rocket can be described by the string — concatenation of letters, which correspond to the stages.

There are n stages available. The rocket must contain exactly k of them. Stages in the rocket should be ordered by their weight. So, after the stage with some letter can go only stage with a letter, which is at least two positions after in the alphabet (skipping one letter in between, or even more). For example, after letter 'c' can't go letters 'a', 'b', 'c' and 'd', but can go letters 'e', 'f', ..., 'z'.

For the rocket to fly as far as possible, its weight should be minimal. The weight of the rocket is equal to the sum of the weights of its stages. The weight of the stage is the number of its letter in the alphabet. For example, the stage 'a 'weighs one ton,' b 'weighs two tons, and' z' — 26 tons.

Build the rocket with the minimal weight or determine, that it is impossible to build a rocket at all. Each stage can be used at most once.

Input

The first line of input contains two integers — n and k (1 ≤ k ≤ n ≤ 50) – the number of available stages and the number of stages to use in the rocket.

The second line contains string s, which consists of exactly n lowercase Latin letters. Each letter defines a new stage, which can be used to build the rocket. Each stage can be used at most once.

Output

Print a single integer — the minimal total weight of the rocket or -1, if it is impossible to build the rocket at all.

Examples

Input

5 3
xyabd


Output

29

Input

7 4
problem


Output

34

Input

2 2
ab


Output

-1

Input

12 1
abaabbaaabbb


Output

1

Note

In the first example, the following rockets satisfy the condition:

  * "adx" (weight is 1+4+24=29);
  * "ady" (weight is 1+4+25=30);
  * "bdx" (weight is 2+4+24=30);
  * "bdy" (weight is 2+4+25=31).



Rocket "adx" has the minimal weight, so the answer is 29.

In the second example, target rocket is "belo". Its weight is 2+5+12+15=34.

In the third example, n=k=2, so the rocket must have both stages: 'a' and 'b'. This rocket doesn't satisfy the condition, because these letters are adjacent in the alphabet. Answer is -1.
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.math.BigInteger;

public class Main {

	private static final int MOD  = 1_000_000_007;
	
	static InputStream inputStream = System.in;
	static OutputStream outputStream = System.out;
	static InputReader in = new InputReader(inputStream);
	static OutputWriter out = new OutputWriter(outputStream);

	static String [] SS;
	static int index;
	
	static Set<String> set = new HashSet<String>();
	
	public static void main(String[] args) {
		
		
		int n = in.nextInt();
		int k  = in.nextInt();
		
		String S = in.next();
		
		char [] c = S.toCharArray();
		
		Arrays.sort(c);
				
		int min = getWeight(c[0]);
		int count = 1;
		
		if(k==1) System.out.println(min);
		
		else {
		
			int index = 0;
			
			for (int i = 1 ; i < c.length ; i++) {
				
				if(count==k) break;
				
				if(isPossible(c[index], c[i])) {
					min+=getWeight(c[i]);
					index = i;
					count++;
				}
				
			}
			
			if(count==1) System.out.println(-1);
			else {
				System.out.println(min);
			}
		}
		
		out.flush();
		out.close();
	}
	
	private static int getWeight(char c) {
		return c - 96;
	}
	
	private static boolean isPossible (char a, char b) {
		return b-a>=2;
	}
	
	private static String toBinaryString(BigInteger d) {
		
		if(d.equals(BigInteger.ZERO)) return "0";
		
		BigInteger two = new BigInteger("2");
		
		String ans = "";
		
		while(d.compareTo(BigInteger.ZERO) > 0) {
			ans = d.remainder(two) + ans;
			d = d.divide(two);
		}
		
		return ans;
	}
	private static BigInteger toDecany(String S) {
		
		char [] c = S.toCharArray();
		
		int num = 0;
		BigInteger number = BigInteger.ZERO;
		
		for(int i = c.length -1;i>=0;i--) {
			number=number.add(
					BigInteger.valueOf(
					(long)(determineChar(c[i])* Math.pow(2, num))));
			num++;
		}		
		
		return number;
	}
	
	private static int determineChar(char c) {
		return c=='0' ? 0 : 1;
	}
	
	 private static void permutation(String prefix, String s)
	 {
		  int n = s.length();
		  
		  if (n == 0)  {
			  if(!prefix.startsWith("0"))
				  set.add(prefix);		  
		  }
		  
		  else
		  {
		       for (int i = 0; i < n; i++)
		    	  permutation(prefix + s.charAt(i),
		    			   s.substring(0, i) + s.substring(i+1, n));
		       
		  }

	 }
	static int factorial(int n) {
		int p = 1;
		for (int i = 1; i <=n; i++) {
			p*=i;
		}
		return p;
	}
	static boolean isPowerOfTwo (int n) {
		return (n&(n-1))==0;
	}
	static int primes(long a, long b, long n) {
		int count = 0;
		for (long i = a; i <=b; i++) {
			if(gcd(i, n)==1) count++;
		}
		
		return count;
	}
	 
	static int count(int n)
	{	
		int sum = 0;
		int shared = 5;
		
		for (int i = 0; i < n; i++) {
			int liked = shared/2;
			shared = liked * 3;
			sum+=liked;
		}
		
		return sum;
	}
	static long F (int n) {
	
		
		long previous = 0;
		long current = 0;
		
		for (int i = 1; i < n; i++) {
			if((i+1)%2==0) {
				current = (previous*(i+1)+1)%MOD;
			}
			else {
				current = (previous*(i+1)-1)%MOD;
			}
			
			previous = current;
		}
		
		return current;
	}

	static boolean isBrackets (String S) {
		
		Stack<Character> stack = new Stack<>(); 
		
		char [] cc = S.toCharArray();
		
		for (char c : cc) {
			if(c=='(' || c=='[') stack.push(c);
			else  {
				
				if(stack.isEmpty()) return false;
				
				if(c==')') {					
					if(stack.pop()!='(') return false;
				}
				else {
					if(stack.pop()!='[') return false;
				}
			}
		}

		return stack.isEmpty();	
		
	}
	static boolean isTrue(String S) {
		int count = 0;
		
		char [] cc = S.toCharArray();
		
		for (char c : cc) {
			if(c=='(' || c=='[') count++;
			else count--;
		}
		if(count<0) return false;
		return count==0;
	}
	static long SumInInterval (long [] a, int l, int r) {
		
		long right = 0;
		long left = 0;
		
		if(r-1<0 ) {
			right = 0;				
		}
		else {
			right = a[r-1];
		}
		if(l-2<0) {
			left = 0;
		}
		else {
			left=a[l-2];
		}
		return right - left;
	}
	
	static long SumLongVersion (long [] a, int l,int r) {
		
		long sum = 0;
		
		for (int i = l; i <=r; i++) {
			sum+=a[i];
		}
		
		return sum;
		
	}
	
	static int minInList (ArrayList<Integer> list) {
		
		int min = list.get(0);
		
		for (int i = 1; i < list.size(); i++) {
			if(list.get(i)<min) {
				min = list.get(i);
			}
		}
		
		return min;
	}
	
	static int maxInList (ArrayList<Integer> list) {
		
		int max = list.get(0);
		
		for (int i = 1; i < list.size(); i++) {
			if(list.get(i)>max) {
				max = list.get(i);
			}
		}
		
		return max;
	}


	static HashMap<Integer, Integer> allPrimeDelimers (int n, int [] primes) {
		HashMap<Integer, Integer> map = new HashMap<>();
		
		int i = 0;
		
		while(n>1)
		{
			int prime = primes[i];
			
			if(n%prime==0) {
				Integer in = map.get(prime);
				map.put(prime , in == null ? 1 : map.get(prime) + 1);
				n/=prime;
			}
			else {
				i++;
			}
		}
		
		return map;
	}
	
	static boolean isPrime (int n) {
		
		if(n<2) return false;
		
		for (int i = 2; i*i<=n; i++) {
			if(n%i==0) return false;
		}
		
		return true;
	}
	
	private static long gcd(long a,long b) {
		return b==0 ? a : gcd(b,a%b);
	}
	

	
	private static String toBinary (int n) {
		
		String S = "";
		
		while(n>0) {
			S=n%2+S;
			n/=2;
		}
		return S;
	}
	
	static boolean isPalindrome(String S) {
		
		char [] c = S.toCharArray();
		
		for (int i = 0; i < c.length; i++) {
			if(c[i]!=c[c.length-1-i]) return false;
		}
		
		return true;
	}
	
	static int binarySearch (int [] a,int element)
	{	
		int low = 0;
		int end = a.length - 1;
		
		while(low<=end)
		{			
			int mid = low + (end-low) / 2;			
			if(element == a[mid]) return mid;
			else if(element < a[mid]) end = mid - 1;
			else low = mid+ 1;					
		}
		
		return -1;
	}
	
	static int lowerBound(int [] a, int element) {
		
		int low = 0;
		int high = a.length - 1;
		
		while(low<high) {
			int mid = low + (high - low)/2;
			if(element>a[mid]) low = mid +1;
			else high = mid;
		}
		
		return low;
	}
	static int upperBound (int [] a, int element) {
		int low = 0;
		int high = a.length - 1;
		
		while(low<high) {
			int mid = low + (high - low)/2;
			if(a[mid]> element) high = mid;
			else low = mid + 1;
		}
		return low;
	}
	 static class InputReader extends BufferedReader {
	        StringTokenizer tokenizer;

	        public InputReader(InputStream inputStream) {
	            super(new InputStreamReader(inputStream), 32768);
	        }

	        public InputReader(String filename) {
	            super(new InputStreamReader(Thread.currentThread().getContextClassLoader().getResourceAsStream(filename)));
	        }

	        public String next() {
	            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
	                try {
	                    tokenizer = new StringTokenizer(readLine());
	                } catch (IOException e) {
	                    throw new RuntimeException();
	                }
	            }
	            return tokenizer.nextToken();
	        }

	        public Integer nextInt() {
	            return Integer.valueOf(next());
	        }
	        
	        public Long nextLong() {
	        	return Long.valueOf(next());
	        }

	        public int[] readIntArray(int size) {
	            int[] array = new int[size];
	            for (int i = 0; i < size; i++)
	                array[i] = nextInt();
	            return array;
	        }
	 }

	    static class OutputWriter extends PrintWriter {
	        public OutputWriter(OutputStream outputStream) {
	            super(outputStream);
	        }

	        public OutputWriter(Writer writer) {
	            super(writer);
	        }

	        public OutputWriter(String filename) throws FileNotFoundException {
	            super(filename);
	        }

	        public void close() {
	            super.close();
	        }

	    }

}


