Problem: Problem statement

The spellbook you have contains $ N $ of spells.

Magic is numbered from $ 1 $ to $ N $, and the cost of magic $ i (1 \ le i \ le N) $ is initially an integer $ A_i $.

Your goal is to cast all the spells in the spellbook $ 1 $ each.

You can eat $ K $ of cookies before you start casting magic. It doesn't take long to eat cookies.

For every $ 1 $ you eat a cookie, you can choose a magic with a positive cost of $ 1 $ and reduce that cost by $ 1 $.

After eating the cookie, you start casting magic.

Your MP is initially $ M $. You repeat either of the following to cast $ N $ of magic $ 1 $ in any order.

* Choose an integer $ i (1 \ le i \ le N) $ for $ 1 $ and cast the magical $ i $. However, the current MP must cost more than the magical $ i $.
* Time does not elapse.
* Consume MP for the cost of magical $ i $.
* Rest. However, if the current MP is $ m $, then $ m <M $ must be.
* Time elapses $ M --m $.
* Recover $ 1 $ MP.



Find the minimum amount of time it will take you to cast $ N $ of spells $ 1 $ each in any order.

Constraint

* $ 1 \ leq N \ leq 10 ^ 5 $
* $ 1 \ leq M \ leq 10 ^ 6 $
* $ 0 \ leq K \ leq \ sum_ {i = 1} ^ {N} A_i $
* $ 1 \ leq A_i \ leq M $
* All inputs are integers.



* * *

input

Input is given from standard input in the following format.


$ N $ $ M $ $ K $
$ A_1 $ $ A_2 $ $ \ ldots $ $ A_N $


output

Print the minimum amount of time it takes to cast $ N $ of magic $ 1 $ each.

* * *

Input example 1


2 4 0
twenty four


Output example 1


3


Since the cost of any magic cannot be reduced, I will continue to cast magic as it is.

* First, cast the magic $ 1 $. It consumes $ 2 $ of MP, so the remaining MP is $ 4-2 = 2 $.



You cannot cast magic $ 2 $ as it is because you need $ 4 $ MP to cast magic $ 2 $.

* I'll take a rest. Time elapses $ 4-2 = 2 $ seconds. It recovers $ 1 $ of MP, so the remaining MP is $ 2 + 1 = 3 $.
* I'll take a rest. Time elapses $ 4-3 = 1 $ seconds. It recovers $ 1 $ of MP, so the remaining MP is $ 3 + 1 = 4 $.
* Cast magic $ 2 $. It consumes $ 4 $ of MP, so the remaining MP is $ 4-4 = 0 $.



From the above, if the time is $ 2 + 1 = 3 $ seconds, the magic $ 1,2 $ can be cast $ 1 $ each time. You can't cast all the spells in less time, so the answer you're looking for is $ 3 $.

* * *

Input example 2


3 9 6
2 3 9


Output example 2


0


With a final magic cost of $ 2, 2, 4 $, you can cast all the magic without a break.

* * *

Input example 3


3 16 2
6 9 9


Output example 3


twenty one


* * *

Input example 4


2 1000000 0
1000000 1000000


Output example 4


500000500000


The answer may not fit in the range that can be represented by a 32-bit integer.





Example

Input

2 4 0
2 4


Output

3

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,n) for (int i=a;i<n;i++)
#define per(i,a,n) for (int i=n-1;i>=a;i--)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
typedef vector<int> VI;
typedef long long ll;
typedef pair<int,int> PII;
typedef double db;
mt19937 mrand(1); 
const ll mod=998244353;
int rnd(int x) { return mrand() % x;}
ll powmod(ll a,ll b) {ll res=1;a%=mod; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}
ll gcd(ll a,ll b) { return b?gcd(b,a%b):a;}
// head

const int N=101000;
#define kill assss
int n,m,a[N],kill[N];
ll k,rm,ans;
int main() {
	scanf("%d%d%lld",&n,&m,&k);
	rep(i,0,n) scanf("%d",a+i);
	sort(a,a+n);
	rep(i,0,n) rm+=a[i];
	rep(i,0,n) {
		if (rm<=m) break;
		if (rm-a[i]>m) kill[i]=a[i];
		else {
			int l=a[i],r=m-(rm-a[i]);
			kill[i]=l-r;
		}
		rm-=a[i];
	}

	int l=-1,r=m;
	while (l+1<r) {
		int md=(l+r)>>1;
		ll s=0;
		rep(i,0,n) s+=min(max(a[i]-md,0),kill[i]);
		if (s<=k) r=md; else l=md;
	}
	rep(i,0,n) {
		int d=min(max(a[i]-r,0),kill[i]);
		k-=d;
		a[i]-=d;
		kill[i]-=d;
	}
	rep(i,0,n) if (k&&a[i]==r&&kill[i]) --k,--a[i],--kill[i];
	/*rep(i,0,n) printf("%d ",a[i]); 
	puts("");*/
	sort(a,a+n);
	rm=0;
	rep(i,0,n) rm+=a[i];
	rep(i,0,n) {
		if (rm<=m) break;
		if (rm-a[i]>m) ans+=(ll)a[i]*(a[i]+1)/2;
		else {
			int l=a[i],r=m-(rm-a[i])+1;
		//	printf("%d %d\n",l,r);
			ans+=(ll)(l+r)*(l-r+1)/2;
		}
		rm-=a[i];
	}
	printf("%lld\n",ans);
}