Luba has to do n chores today. i-th chore takes ai units of time to complete. It is guaranteed that for every <image> the condition ai ≥ ai - 1 is met, so the sequence is sorted.

Also Luba can work really hard on some chores. She can choose not more than k any chores and do each of them in x units of time instead of ai (<image>).

Luba is very responsible, so she has to do all n chores, and now she wants to know the minimum time she needs to do everything. Luba cannot do two chores simultaneously.

Input

The first line contains three integers n, k, x (1 ≤ k ≤ n ≤ 100, 1 ≤ x ≤ 99) — the number of chores Luba has to do, the number of chores she can do in x units of time, and the number x itself.

The second line contains n integer numbers ai (2 ≤ ai ≤ 100) — the time Luba has to spend to do i-th chore.

It is guaranteed that <image>, and for each <image> ai ≥ ai - 1.

Output

Print one number — minimum time Luba needs to do all n chores.

Examples

Input

4 2 2
3 6 7 10


Output

13


Input

5 2 1
100 100 100 100 100


Output

302

Note

In the first example the best option would be to do the third and the fourth chore, spending x = 2 time on each instead of a3 and a4, respectively. Then the answer is 3 + 6 + 2 + 2 = 13.

In the second example Luba can choose any two chores to spend x time on them instead of ai. So the answer is 100·3 + 2·1 = 302.
import java.util.*;
import java.io.*;
public class Main
{
 
	static ArrayList<Integer> adj[];
	static char color[];
	static boolean b[],visited[],possible;
	static int level[];
	static Map<Integer,HashSet<Integer>> s;
	static int totalnodes,colored;
	static int count[];
	static long sum[];
	static int nodes;
	static double ans=0;
	static long[] as=new long[10001];
	static long c1=0,c2=0;
	static int[] a,d,k;
	static int max=100000000;
	static long MOD = (long)1e9 + 7;
	static boolean[] prime=new boolean[100005];
	public static void main(String[] args) throws IOException
	{
		in=new InputReader(System.in);
		w=new PrintWriter(System.out);
		int n=in.nextInt(),k=in.nextInt(),x=in.nextInt();
      int ans=k*x;
      int[] a=new int[n];
      for(int i=0;i<n;i++)
    	  a[i]=in.nextInt();
      Arrays.sort(a);
      for(int i=0;i<n-k;i++)
    	  ans+=a[i];
      w.print(ans);
		w.close();
    }
	public static void sieveOfEratosthenes()
	    {
	       int n=prime.length;
	        for(int i=0;i<n;i++)
	            prime[i] = true;
	         
	        for(int p = 2; p*p <=n; p++)
	        {
	            if(prime[p] == true)
	            {
	                for(int i = p*2; i <= n; i += p)
	                    prime[i] = false;
	            }
	        }
	    }
	public static int[] kthAncestors(int[] a,int[] c,int n,int k)
	{
		int[] ans=new int[n+1];
		ans[1]=-1;
		for(int i=2;i<=n;i++)
		{
			int temp=0;
			boolean r=false;
			int j=i;
			while(a[j]!=j)
			{
				if(c[j]==c[a[j]])
					temp++;
				if(temp==k)
					{
					ans[i]=a[j];
					r=true;
					break;
					}
				j=a[j];
			}
			if(r==false)
				ans[i]=-1;
		}
		
		return ans;
	}
	public static void printDivisors(int n)
    {
        for (int i=1; i<=Math.sqrt(n); i++)
        {
            if (n%i==0)
            {
                if (n/i == i)
                    k[i]++;
                else 
                {
                	k[i]++;
                	k[n/i]++;
                }
            }
        }
    }
   private static void nextIntArray() 
	{
	   int n=a.length;
		 for(int i=0;i<n;i++)
			 a[i]=in.nextInt();
		
	}
	
  public static void bfs()
  {
	 level[1]=1;
	 visited[1]=true;
	 Queue<Integer> q=new LinkedList<Integer>();
	 q.add(1);
	 while(!q.isEmpty())
	 {
		 int t=q.poll();
		 for(int i=0;i<adj[t].size();i++)
		 {
			 if(!visited[adj[t].get(i)])
			 {
				 level[adj[t].get(i)]=level[t]+1;
				 visited[adj[t].get(i)]=true;
				 q.add(adj[t].get(i));
			 }
		 }
	 }
  }
  
  public static void dfs(int i)
  {
	  visited[i]=true;
	  for(int j:adj[i])
	  {
		  if(!visited[j])
			  {
			  dfs(j);
			  nodes++;
			  }
	  }
	  
  }
  public static String rev(String s)
	{
		StringBuilder sb=new StringBuilder(s);
		sb.reverse();
		return sb.toString();
	}
	static long lcm(long a, long b)
	{
	    return a * (b / gcd(a, b));
	}
	static long gcd(long a, long b)
	{
	    while (b > 0)
	    {
	        long temp = b;
	        b = a % b; // % is remainder
	        a = temp;
	    }
	    return a;
	}
	static InputReader in;
	static PrintWriter w;
static class InputReader 
{
 
private final InputStream stream;
private final byte[] buf = new byte[8192];
private int curChar, snumChars;
private SpaceCharFilter filter;
 
public InputReader(InputStream stream)
{
  this.stream = stream;
}
 
public int snext()
{
  if (snumChars == -1)
    throw new InputMismatchException();
  if (curChar >= snumChars)
  {
    curChar = 0;
    try 
    {
      snumChars = stream.read(buf);
    }
    catch (IOException e)
    {
      throw new InputMismatchException();
    }
    if (snumChars <= 0)
      return -1;
  }
  return buf[curChar++];
}
 
public int nextInt() 
{
  int c = snext();
  while (isSpaceChar(c)) 
  {
    c = snext();
  }
  int sgn = 1;
  if (c == '-')
  {
    sgn = -1;
    c = snext();
  }
  int res = 0;
  do
  {
    if (c < '0' || c > '9')
      throw new InputMismatchException();
    res *= 10;
    res += c - '0';
    c = snext();
  }
  while (!isSpaceChar(c));
  return res * sgn;
}
 
public long nextLong() 
{
  int c = snext();
  while (isSpaceChar(c)) 
  {
    c = snext();
  }
  int sgn = 1;
  if (c == '-')
  {
    sgn = -1;
    c = snext();
  }
  long res = 0;
  do
  {
    if (c < '0' || c > '9')
      throw new InputMismatchException();
    res *= 10;
    res += c - '0';
    c = snext();
  }
  while (!isSpaceChar(c));
  return res * sgn;
}
 
public static void nextIntArray(int n) 
{
	 for(int i=0;i<n;i++)
		 a[i]=in.nextInt();
}
	    
public int[] nextIntArray(int n, int off)
{
	 int[] arr = new int[n + off];
	   for (int i = 0; i < n; i++)
	   {
	    arr[i + off] = nextInt();
	    }
	    return arr;
	    }
	    
public long[] nextLongArray(int n)
{
return nextLongArray(n, 0);
	    }
        
	public long[] nextLongArray(int n, int off)
	{
	 long[] arr = new long[n + off];
	 for (int i = 0; i < n; i++)
	 {
		  arr[i + off] = nextLong();
		 }
 return arr;
	}
 
 
public String readString() 
{
  int c = snext();
  while (isSpaceChar(c)) 
  {
    c = snext();
  }
  StringBuilder res = new StringBuilder();
  do
  {
    res.appendCodePoint(c);
    c = snext();
  }
  while (!isSpaceChar(c));
  return res.toString();
}
 
public String nextLine() 
{
  int c = snext();
  while (isSpaceChar(c))
    c = snext();
  StringBuilder res = new StringBuilder();
  do
  {
    res.appendCodePoint(c);
    c = snext();
  }
  while (!isEndOfLine(c));
  return res.toString();
}
 
public boolean isSpaceChar(int c)
{
  if (filter != null)
    return filter.isSpaceChar(c);
  return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
 
private boolean isEndOfLine(int c) 
{
  return c == '\n' || c == '\r' || c == -1;
}
 
public interface SpaceCharFilter
{
  public boolean isSpaceChar(int ch);
}
}
	
}