human
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.

Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player. 

Alex is a perfectionist, so he decided to get as many points as possible. Help him.

Input

The first line contains integer n (1 ≤ n ≤ 105) that shows how many numbers are in Alex's sequence. 

The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105).

Output

Print a single integer — the maximum number of points that Alex can earn.

Examples

Input

2
1 2

Output

2

Input

3
1 2 3

Output

4

Input

9
1 2 1 3 2 2 2 2 3

Output

10

Note

Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points.
assistant
#Here is Python program to print a single integer — the maximum number of points that Alex can earn.

import bisect
import os, sys, atexit
from io import BytesIO, StringIO
 
# input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
# _OUTPUT_BUFFER = StringIO()
# sys.stdout = _OUTPUT_BUFFER
 
# @atexit.register
# def write():
#     sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())

dp = [-1]*100001
# sys.setrecursionlimit(100001)
def calculate(i):
    if dp[i]!=-1:
        return dp[i]
    if i<0:
        return 0
    if i==0:
        dp[i] = arr[i]
    else:
        leftindex = bisect.bisect_left(arr,arr[i])
        if leftindex==0 or arr[leftindex-1]!=arr[i]-1:
            dp[i]= arr[i]*(i-leftindex+1)+calculate(leftindex-1)
        else:
            leftestIndex = bisect.bisect_left(arr,arr[leftindex-1])
            dp[i] = max(arr[i]*(i-leftindex+1)+calculate(leftestIndex-1),calculate(leftindex-1))
    return dp[i]

def solve():
    n = int(input())
    arr = list(map(int,input().split()))
    arr.sort()
    arr.append(1000000)
    dp[1],dp[0]=arr[0],0
    # print (arr)
    for i in range(1,n):
        if arr[i]!=arr[i+1]:
            leftindex = bisect.bisect_left(arr,arr[i])
            if arr[leftindex-1]!=arr[i]-1:
                dp[i+1]= arr[i]*(i-leftindex+1)+dp[leftindex]
            else:
                leftestIndex = bisect.bisect_left(arr,arr[leftindex-1])
                dp[i+1] = max(arr[i]*(i-leftindex+1)+dp[leftestIndex],dp[leftindex])
    print (dp[n])
    
try:
    solve()
except Exception as e:
    print (e)
# solve()