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 javafx.util.Pair;

import java.io.*;
import java.sql.Array;
import java.util.*;
public class test {
    int max = 0;
    long max1 = 0;
    boolean visited[];
    PrintStream out = System.out;
    int sign[] = {1, 0, -1, 0, 0, 1, 0, -1};
    ArrayList<Integer> queue = new ArrayList<>();

    public static void main(String args[]) throws IOException {
        test obj = new test();
        obj.start();
    }

    void start() throws IOException {
        Reader sc = new Reader();
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        // Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
        int a[]=intArray(n,sc);
        Arrays.sort(a);
        long count=a[n-1];
        long sum=a[n-1];
        for(int i=n-2;i>=0;i--)
        {
            if(count-1<0)
            continue;
          sum+=Math.min(a[i],count-1);
            count=Math.min(a[i],count-1);
        }
        out.println(sum);
    }

    //<---------------------------------------------------------------------------------------------------------------->//


    //printing 2-d array
    private void println(int[][] a,int n,int m) {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
                System.out.print(a[i][j]);
            System.out.println();
        }

    }


    //modified dfs for chessboard, matrix
    void dfs(char a[][],int i,int j,char t,int n,int m)
    {
        //visited[i]=true;
        a[i][j]=t;
        if(t=='B')
            t='W';
        else
            t='B';
        for (int c= 0; c < 4; c++) {

            int temp=i+sign[2*c];
            int temp2=j+sign[2*c+1];
            if(temp>=0&&temp<n&&temp2>=0&&temp2<m) {
                if(a[temp][temp2]=='.'&&a[temp][temp2]!='-')
                    dfs(a,temp,temp2,t,n,m);
            }
        }
    }


     //constructing segment tree
    private void constructseg(long[] seg, long[] input, int p, int q, int pos) {
        if(p==q)
        {
            seg[pos]=input[p];
            return;
        }
        int mid=(q+p)/2;
        constructseg(seg,input,p,mid,2*pos+1);
        constructseg(seg,input,mid+1,q,2*pos+2);
        seg[pos]=seg[2*pos+1]+seg[2*pos+2];
    }


    //traversing through a arrayList graph
    void dfs(ArrayList<Integer> node[],int i)
    {
        visited[i]=true;
   /*     if(cat[i]==1) {
            count++;
        }
        else
            count=0;
        if(count>k) {
            return;
        }
        if(node[i].size()==1&&i!=0) {
            max += 1;
        }*/
        for (int j = 0; j < node[i].size(); j++) {
            if(!visited[node[i].get(j)])
                dfs(node, node[i].get(j));
        }

    }


    //printing arraylist array
    void println(ArrayList<Integer> a[])
    {
          for (ArrayList<Integer> b:a
               ) {
              System.out.println(b.toString());
          }
    }

    //sorting 2 array based on a, Complexity is O(n^2)
    void sort(int a[],int b[],int n)
    {
        for(int i=1;i<n;i++)
        {
            int index=i;
            for(int j=i-1;j>=0;j--)
            {
              //  println(a);
                if(a[index]<a[j])
                {
                    int temp=a[index];
                    int temp2=b[index];
                    a[index]=a[j];
                    b[index]=b[j];
                    a[j]=temp;
                    b[j]=temp2;
                    index=j;

                }
                else
                    break;
            }
        }

    }
     // to create and initialize Integer array
    private int[] intArray(int a, Scanner sc) {
        int temp[]=new int[a];
        for(int i=0;i<a;i++) {
            temp[i]=sc.nextInt();
        }
        return temp;
    }

    private int[] intArray(int a, Reader sc) throws IOException {
        int temp[]=new int[a];
        for(int i=0;i<a;i++) {
            temp[i]=sc.nextInt();
        }
        return temp;
    }// / to create and initialize Long Array
    private long[] longArray(int a, Scanner sc) {
        long temp[]=new long[a];
        for(int i=0;i<a;i++) {
            temp[i]=sc.nextLong();
        }
        return temp;
    }

    // displaying Map contents key--value
    public static void printMap(Map mp) {
        Iterator it = mp.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry pair = (Map.Entry)it.next();
            System.out.println(pair.getKey() + " = " + pair.getValue());
            it.remove(); // avoids a ConcurrentModificationException
        }
    }


    // Return arrayList of minimum factor of number
    // 24= 2*2*2*3;
    private ArrayList<Integer> minFactor(int a) {
        ArrayList<Integer> obj=new ArrayList<>();
        for(int i=2;i<=a;i++)
        {
            while(a!=0&&a%i==0)
            {
                obj.add(i);
                a/=i;
            }
        }
        return obj;
    }


    // check whether the number is prime or not
    public static boolean isPrimeNumber(int i) {
        int factors = 0;
        int j = 1;

        while(j <= i)
        {
            if(i % j == 0)
            {
                factors++;
            }
            j++;
        }
        return (factors == 2);
    }

    // creating and initializing arrayList
    private void initArrayList(ArrayList<Integer>[] tempa) {
        for(int i=0;i<tempa.length;i++)
            tempa[i]=new ArrayList<>();
    }

    // return factorial contents as ArrayList
    private ArrayList<Integer> factdigit(int i)
    {
        ArrayList<Integer> temp=new ArrayList<>();
        for(int j=i;j>1;j--)
        {
            temp.add(j);
        }
        return temp;
    }

    //printing Integer array
    private  void println(int a[])
    {
        for(int i=0;i<a.length;i++)
            System.out.print(a[i]+" ");
    }
    int factorial(int n){
        if (n == 0)
            return 1;
        else
            return((n %1000000007)* (factorial(n-1)%1000000007));
    }
}





class Reader {
    final private int BUFFER_SIZE = 1 << 16;
    private DataInputStream din;
    private byte[] buffer;
    private int bufferPointer, bytesRead;

    public Reader() {
        din = new DataInputStream(System.in);
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public Reader(String file_name) throws IOException {
        din = new DataInputStream(new FileInputStream(file_name));
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public String readLine() throws IOException {
        byte[] buf = new byte[300]; // line length
        int cnt = 0, c;
        while ((c = read()) != -1) {
            if (c == '\n')
                break;
            buf[cnt++] = (byte) c;
        }
        return new String(buf, 0, cnt);
    }

    public int nextInt() throws IOException {
        int ret = 0;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();
        do {
            ret = ret * 10 + c - '0';
        } while ((c = read()) >= '0' && c <= '9');

        if (neg)
            return -ret;
        return ret;
    }

    public long nextLong() throws IOException {
        long ret = 0;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();
        do {
            ret = ret * 10 + c - '0';
        }
        while ((c = read()) >= '0' && c <= '9');
        if (neg)
            return -ret;
        return ret;
    }

    public double nextDouble() throws IOException {
        double ret = 0, div = 1;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();

        do {
            ret = ret * 10 + c - '0';
        }
        while ((c = read()) >= '0' && c <= '9');

        if (c == '.') {
            while ((c = read()) >= '0' && c <= '9') {
                ret += (c - '0') / (div *= 10);
            }
        }

        if (neg)
            return -ret;
        return ret;
    }

    private void fillBuffer() throws IOException {
        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
        if (bytesRead == -1)
            buffer[0] = -1;
    }

    private byte read() throws IOException {
        if (bufferPointer == bytesRead)
            fillBuffer();
        return buffer[bufferPointer++];
    }

    public void close() throws IOException {
        if (din == null)
            return;
        din.close();
    }
}
