You are given an alphabet consisting of n letters, your task is to make a string of the maximum possible length so that the following conditions are satisfied: 

  * the i-th letter occurs in the string no more than ai times; 
  * the number of occurrences of each letter in the string must be distinct for all the letters that occurred in the string at least once. 

Input

The first line of the input contains a single integer n (2 ≤ n ≤ 26) — the number of letters in the alphabet.

The next line contains n integers ai (1 ≤ ai ≤ 109) — i-th of these integers gives the limitation on the number of occurrences of the i-th character in the string.

Output

Print a single integer — the maximum length of the string that meets all the requirements.

Examples

Input

3
2 5 5


Output

11


Input

3
1 1 2


Output

3

Note

For convenience let's consider an alphabet consisting of three letters: "a", "b", "c". In the first sample, some of the optimal strings are: "cccaabbccbb", "aabcbcbcbcb". In the second sample some of the optimal strings are: "acc", "cbc".

    import java.io.*;

    import java.math.BigInteger;
    import java.util.*;

    public class Main {
    	//static int flag=1;
    	private static InputStream stream;
    	private static byte[] buf=new byte[1024];
    	private static int curChar;
    	private static int numChars;
    	private static SpaceCharFilter filter;
    	private static PrintWriter pw;
    	private static long count=0;
        public static void main(String args[] ) throws Exception 
        {
        	InputReader(System.in);
    		pw=new PrintWriter(System.out);
    		soln();
    		pw.close();
        }


        
  private static void soln() {	  
	int n=nextInt();
	int a[]=nextIntArray(n);
	Arrays.sort(a);
	int count=0;
	long sum=0;
	for(int i=n-1;i>=0;i--){
		
		if(i==(n-1)){
			sum+=(long)a[i];
			count=a[i]-1;
		}else{
			if(a[i]<count){
				sum+=(long)a[i];
				count=a[i]-1;
			}else{
				sum+=(long)count;
				count--;
			}
		}
		if(count==0)
			break;
	}
	System.out.println(sum);
 }
	
 
public static boolean PointInTriangle(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8)
{
int s = p2 * p5 - p1 * p6 + (p6 - p2) * p7 + (p1 - p5) * p8;
int t = p1 * p4 - p2 * p3 + (p2 - p4) * p7 + (p3 - p1) * p8;

if ((s < 0) != (t < 0))
return false;

int A = -p4 * p5 + p2 * (p5 - p3) + p1 * (p4 - p6) + p3 * p6;
if (A < 0.0)
{
s = -s;
t = -t;
A = -A;
}
return s > 0 && t > 0 && (s + t) <= A;
}

  public static float area(int x1, int y1, int x2, int y2, int x3, int y3){
	  return (float)Math.abs((x1*(y2-y3) + x2*(y3-y1)+ x3*(y1-y2))/2.0);
  }
  public static boolean isPrime(int n)
  {
      // Corner cases
      if (n <= 1)  return false;
      if (n <= 3)  return true;
   
      // This is checked so that we can skip 
      // middle five numbers in below loop
      if (n%2 == 0 || n%3 == 0) return false;
   
      for (int i=5; i*i<=n; i=i+6)
          if (n%i == 0 || n%(i+2) == 0)
             return false;
   
      return true;
  }


//merge Sort
        
        public static void Merge_sort(int a[]){
        	int len=a.length;
        	if(len <2)
        		return ;
        	int mid=len/2;
        	int l[]=new int[mid];
        	int r[] =new int[len-mid];
        	for(int i=0;i<mid;i++)
        		l[i]=a[i];
        	for(int i=mid;i<len;i++)
        		r[i-mid]=a[i];
        	
        	Merge_sort(l);
        	Merge_sort(r);
        	Merge(l,r,a);
        }
        	
        public static void Merge(int []l,int[]r,int a[]){
        	int nl=l.length;
        	int nr=r.length;
        	int i=0,j=0,k=0;
        	
        	while(i <nl && j<nr){
        		if(l[i] > r[j]){
        			a[k]=l[i];
        			k++;
        			i++;
        		}
        		else{
        			a[k]=r[j];
        			k++;
        			j++;
        		}
        		
        		while(i<nl){
        			a[k]=l[i];
        			k++;
        			i++;
        		}
        		while(j<nr){
        			a[k]=r[j];
        			k++;
        			j++;
        		}
        	}
        }
  
    	
    public static boolean isSubSequence(String large,String small,int largeLen,int smallLen){
    //base cases
    	if(largeLen==0)
    		return false;
    	if(smallLen==0)
    		return true;
    	  // If last characters of two strings are matching
    	if(large.charAt(largeLen-1)==small.charAt(smallLen-1))
    		isSubSequence(large, small, largeLen-1, smallLen-1);
    	// If last characters are not matching
    	return isSubSequence(large, small, largeLen-1, smallLen);
    }

    // To Get Input
     	// Some Buffer Methods
     
     	public static void InputReader(InputStream stream1) {
     		stream = stream1;
     	}
     
     	private static boolean isWhitespace(int c) {
     		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
     	}
     
     	private static boolean isEndOfLine(int c) {
     		return c == '\n' || c == '\r' || c == -1;
     	}
     
     	private static int read() {
     		if (numChars == -1)
     			throw new InputMismatchException();
     		if (curChar >= numChars) {
     			curChar = 0;
     			try {
     				numChars = stream.read(buf);
     			} catch (IOException e) {
     				throw new InputMismatchException();
     			}
     			if (numChars <= 0)
     				return -1;
     		}
     		return buf[curChar++];
     	}
     
     	private static int nextInt() {
     		int c = read();
     		while (isSpaceChar(c))
     			c = read();
     		int sgn = 1;
     		if (c == '-') {
     			sgn = -1;
     			c = read();
     		}
     		int res = 0;
     		do {
     			if (c < '0' || c > '9')
     				throw new InputMismatchException();
     			res *= 10;
     			res += c - '0';
     			c = read();
     		} while (!isSpaceChar(c));
     		return res * sgn;
     	}
      
     	private static long nextLong() {
     		int c = read();
     		while (isSpaceChar(c))
     			c = read();
     		int sgn = 1;
     		if (c == '-') {
     			sgn = -1;
     			c = read();
     		}
     		long res = 0;
     		do {
     			if (c < '0' || c > '9')
     				throw new InputMismatchException();
     			res *= 10;
     			res += c - '0';
     			c = read();
     		} while (!isSpaceChar(c));
     		return res * sgn;
     	}
      
     	private static String nextToken() {
     		int c = read();
     		while (isSpaceChar(c))
     			c = read();
     		StringBuilder res = new StringBuilder();
     		do {
     			res.appendCodePoint(c);
     			c = read();
     		} while (!isSpaceChar(c));
     		return res.toString();
     	}
      
     	private static String nextLine() {
     		int c = read();
     		while (isSpaceChar(c))
     			c = read();
     		StringBuilder res = new StringBuilder();
     		do {
     			res.appendCodePoint(c);
     			c = read();
     		} while (!isEndOfLine(c));
     		return res.toString();
     	}
     
     	private static int[] nextIntArray(int n) {
     		int[] arr = new int[n];
     		for (int i = 0; i < n; i++) {
     			arr[i] = nextInt();
     		}
     		return arr;
     	}
     	  
     	private static long[] nextLongArray(int n) {
     		long[] arr = new long[n];
     		for (int i = 0; i < n; i++) {
     			arr[i] = nextLong();
     		}
     		return arr;
     	}
     
     	private static void pArray(int[] arr){
     		for (int i=0; i<arr.length; i++) {
     			System.out.print(arr[i] + " ");
     		}
     		System.out.println();
     		return;
     	}
     
     	private static void pArray(long[] arr){
     		for (int i=0; i<arr.length; i++) {
     			System.out.print(arr[i] + " ");
     		}
     		System.out.println();
     		return;		
     	}
     	
     	private static void pArray(boolean[] arr){
     		for (int i=0; i<arr.length; i++) {
     			System.out.print(arr[i] + " ");
     		}
     		System.out.println();
     		return;
     	}

     
     	private static boolean isSpaceChar(int c) {
     		if (filter != null)
     			return filter.isSpaceChar(c);
     		return isWhitespace(c);
     	}
      
     	private interface SpaceCharFilter {
     		public boolean isSpaceChar(int ch);
     	}
     
     
     
     

  }