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 javax.swing.plaf.synth.SynthSpinnerUI;

import java.io.*;

public class Main {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//DisjointSet set = new DisjointSet(26);
		
		InputReader sc1 = new InputReader(System.in);
		PrintWriter sc2 = new PrintWriter(System.out);
		int n = sc1.nextInt();
		int k = sc1.nextInt();
		int x = sc1.nextInt();
		int a[] = new int[n];
		for(int i=0;i<n;i++) {
			a[i] = sc1.nextInt();
		}
		int sum = 0;
		for(int i=n-1;i>=0;i--) {
			if(k>0) {
				sum += x;
				k--;
			}
			else {
				sum = sum + a[i];
			}
		}
		sc2.println(sum);
		sc2.close();
	}

	/*
	 * 	DIVISORS
	 * */
	public static void divsors(int n) {
		for(int i=1;i<=Math.sqrt(n)+1;i++) {
			if(n%i==0) {
				if(n/i==i) {
					System.out.print(i+" ");
				}
				else {
					System.out.print	(i+" "+n/i);
				}
			}
		}
	}
	
	/*
	 * 	GCD 
	 * */
	
	public static int GCD(int x, int y) {
		if(x==0) {
			return y;
		}
		return GCD(y%x, x);
	}
	
	/*
	 * 	GCD EXTENDED
	 * */
	
	public static int gcdExtended(int a, int b, int x, int y) {
		if(a==0) {
			x = 0;
			y = 1;
			return b;
		}
		
		int x1 = 1, y1 = 1;
		int gcd = gcdExtended(b%a, a, x1, y1);
		x = y1 - (b/a)*x1;
		y = x1;
		
		return gcd;
	}
	
	
	static class DisjointSet{
		static StringBuilder str = new StringBuilder();
		static int count = 0;
		int rank[];
		int parent[];
		int n;
		DisjointSet(int n){
			this.n = n;
			rank = new int[n];
			Arrays.fill(rank, 0);
			parent = new int[n];
			makeSet();
			
		}
		void makeSet() {
			for(int i=0;i<n;i++) {
				parent[i] = i;
			}
		}
		
		int find(int x) {
			if(parent[x]!=x) {
				parent[x] = find(parent[x]);
			}
			return parent[x];
		}
		
		void union(int x, int y) {
			int xRoot = find(x);
			int yRoot = find(y);
			
			if(xRoot==yRoot) {
				return;
			}
			
			if(rank[xRoot]>rank[yRoot]) {
				parent[yRoot] = xRoot;
				Append(x,y);
				count++;
			}
			else if(rank[xRoot]<rank[yRoot]) {
				parent[xRoot] = yRoot;
				Append(x,y);
				count++;
			}
			else {
				parent[yRoot] = xRoot;
				rank[xRoot] = rank[xRoot] + 1;
				count++;
				Append(x,y);
			}
		}
		
		void Append(int x, int y) {
			str.append((char)(x+97)+" "+(char)(y+97)+"\n");
		}
	}
	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 int[] nextIntArray(int n) {
			int a[] = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = nextInt();
			return a;
		}
 
		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 boolean isSpaceChar(int c) {
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}
 
		public interface SpaceCharFilter {
			public boolean isSpaceChar(int ch);
		}
	}	
}

