Every superhero has been given a power value by the Felicity Committee. The avengers crew wants to maximize the average power of the superheroes in their team by performing certain operations.

Initially, there are $n$ superheroes in avengers team having powers $a_1, a_2, \ldots, a_n$, respectively. In one operation, they can remove one superhero from their team (if there are at least two) or they can increase the power of a superhero by $1$. They can do at most $m$ operations. Also, on a particular superhero at most $k$ operations can be done.

Can you help the avengers team to maximize the average power of their crew?


-----Input-----

The first line contains three integers $n$, $k$ and $m$ ($1 \le n \le 10^{5}$, $1 \le k \le 10^{5}$, $1 \le m \le 10^{7}$) — the number of superheroes, the maximum number of times you can increase power of a particular superhero, and the total maximum number of operations.

The second line contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \le a_i \le 10^{6}$) — the initial powers of the superheroes in the cast of avengers.


-----Output-----

Output a single number — the maximum final average power.

Your answer is considered correct if its absolute or relative error does not exceed $10^{-6}$.

Formally, let your answer be $a$, and the jury's answer be $b$. Your answer is accepted if and only if $\frac{|a - b|}{\max{(1, |b|)}} \le 10^{-6}$.


-----Examples-----
Input
2 4 6
4 7

Output
11.00000000000000000000

Input
4 2 6
1 3 2 3

Output
5.00000000000000000000



-----Note-----

In the first example, the maximum average is obtained by deleting the first element and increasing the second element four times.

In the second sample, one of the ways to achieve maximum average is to delete the first and the third element and increase the second and the fourth elements by $2$ each.

Source: codeforces | Difficulty: MEDIUM_HARD
Tags: Mathematics

Implementation

Complete search


Solutions:
(n, k, m) = map(int, input().split())
s = [int(x) for x in input().split()]
S = sorted(s)
S = S[::-1]
dp = [S[0]]
for i in range(1, len(s)):
	dp.append(dp[-1] + S[i])
dp = dp[::-1]
br = len(dp)
for i in range(0, len(dp)):
	if i <= m:
		dp[i] = dp[i] + min(m - i, (n - i) * k)
	else:
		br = i
		break
dp = dp[:br]
ans = -1
for i in range(0, len(dp)):
	ans = max(ans, dp[i] / (n - i))
print(ans)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
s = sum(a)
l = n
m2 = m
maxi = round((s + min(k * l, m2)) / l, 9)
if n - 1 >= m:
	n = m + 1
for i in range(n - 1):
	s -= a[i]
	l -= 1
	m2 -= 1
	maxi = round(max(maxi, (s + min(k * l, m2)) / l), 9)
print(maxi)


(n, k, m) = [int(x) for x in input().split()]
a_is = [int(x) for x in input().split()]
a_is.sort()
total_sum = sum(a_is)
max_avg = (total_sum + min(n * k, m)) / n
for removal in range(1, min(n - 1, m) + 1):
	total_sum -= a_is[removal - 1]
	new_avg = (total_sum + min((n - removal) * k, m - removal)) / (n - removal)
	if new_avg > max_avg:
		max_avg = new_avg
print(max_avg)


import sys
data = sys.stdin.read().splitlines()
(n, k, m) = map(int, data[0].split())
nums = list(map(int, data[1].split()))
nums.sort()
s = sum(nums)
mx = (s + min(m, k * n)) / n
for (idx, num) in enumerate(nums):
	if idx == n - 1:
		break
	if idx < m:
		s -= num
		add = min((n - idx - 1) * k, m - idx - 1)
		mx = max(mx, (s + add) / (n - idx - 1))
	else:
		break
print(mx)


(n, k, m) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a = sorted(a)[::-1]
su = [0]
for i in range(1, n + 1):
	su.append(su[i - 1] + a[i - 1])
ans = 0.0
for i in range(max(1, n - m), n + 1):
	ans = max(ans, (su[i] + min(m - (n - i), i * k)) / i)
print(ans)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
s = 0
for i in a:
	s += i
a = sorted(a)
ans = (s + min(n * k, m)) / n
p = n
for i in range(n - 1):
	s -= a[i]
	m -= 1
	p -= 1
	ans = max(ans, (s + min(p * k, m)) / p)
	if m == 0:
		break
print('%.10f' % ans)


(n, k, m) = list(map(int, input().split()))
a = [int(x) for x in input().split()]
a.sort(reverse=True)
ans = 0
s = 0
for i in range(n):
	s += a[i]
	if n - i - 1 > m:
		continue
	ans = max(ans, float((s + min(m - (n - i - 1), (i + 1) * k)) / (i + 1)))
print(ans)


import sys, math, itertools
from collections import Counter, deque, defaultdict
from bisect import bisect_left, bisect_right
from heapq import heappop, heappush, heapify, nlargest
from copy import deepcopy
mod = 10 ** 9 + 7
INF = float('inf')

def inp():
	return int(sys.stdin.readline())

def inpl():
	return list(map(int, sys.stdin.readline().split()))

def inpl_1():
	return list(map(lambda x: int(x) - 1, sys.stdin.readline().split()))
(n, k, m) = inpl()
a = inpl()
a.sort()
aa = [0]
for x in a:
	aa.append(aa[-1] + x)
res = (aa[-1] + min(m, k * n)) / n
for i in range(1, n):
	if i > m:
		break
	su = aa[-1] - aa[i]
	N = n - i
	now = (su + min(m - i, k * N)) / N
	res = max(res, now)
print(res)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
s = sum(a)
ans = 0
i = 0
while i < n and i <= m:
	r = n - i
	ans = max(ans, (s + min(r * k, m - i)) / r)
	s -= a[i]
	i += 1
print('%.18f' % ans)


(n, k, m) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
l.reverse()
if m > n - 1:
	print(l[0] + min(m - (n - 1), k))
else:
	sum = l[0]
	for i in range(1, n - m):
		sum += l[i]
	ans = sum / (n - m)
	j = 1
	for i in range(n - m, n):
		sum += l[i]
		if ans < (sum + j) / (n - m + j):
			ans = (sum + j) / (n - m + j)
		j += 1
		if k * (n - m + j) < j:
			break
	print(ans)


(n, k, m) = input().split()
n = int(n)
k = int(k)
m = int(m)
a = input().split()
s = 0
for i in range(len(a)):
	a[i] = int(a[i])
	s += a[i]
a.sort()
ans = (s + min(k * n, m)) / n
for i in range(n - 1):
	if i == m:
		break
	s -= a[i]
	ans = max(ans, (s + min(k * (n - i - 1), m - i - 1)) / (n - i - 1))
print(ans)


(n, k, m) = map(int, input().split())
ls = sorted(list(map(int, input().split())), reverse=True)
s = sum(ls)
avg = (min(len(ls) * k, m) + s) / len(ls)
while len(ls) > 1 and m > 0:
	s -= ls.pop(-1)
	m -= 1
	z = (min(len(ls) * k, m) + s) / len(ls)
	if z > avg:
		avg = z
print(avg)


import sys
import math
import collections
import bisect
import itertools
import decimal
import heapq
INF = 10 ** 20
MOD = 10 ** 9 + 7

def ni():
	return int(sys.stdin.buffer.readline())

def ns():
	return map(int, sys.stdin.buffer.readline().split())

def na():
	return list(map(int, sys.stdin.buffer.readline().split()))

def na1():
	return list(map(lambda x: int(x) - 1, sys.stdin.buffer.readline().split()))

def flush():
	return sys.stdout.flush()

def nicf():
	return int(sys.stdin.readline())

def nscf():
	return map(int, sys.stdin.readline().split())

def nacf():
	return list(map(int, sys.stdin.readline().split()))

def na1cf():
	return list(map(lambda x: int(x) - 1, sys.stdin.readline().split()))

def main():
	(n, k, m) = ns()
	a = na()
	a.sort()
	total = sum(a)
	ans = total / n
	if m >= n:
		ans = a[-1] + max(0, min(k, m - (n - 1)))
	else:
		for i in range(m):
			ans = max(ans, (total + min(k * (n - i), m - i)) / (n - i))
			total -= a[i]
			ans = max(ans, total / (n - i - 1))
	print('{:.20f}'.format(ans))
main()


(n, k, m) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
s = sum(arr)
mx = s / n + min(m, n * k) / n
for i in range(n - 1):
	remain = m - i - 1
	val = (s - arr[i]) / (n - (i + 1)) + min(remain, (n - i - 1) * k) / (n - i - 1)
	s -= arr[i]
	if val > mx:
		mx = val
	if remain == 0:
		break
print(mx)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
b = sum(a)
ans = (b + min(n * k, m)) / len(a)
for i in range(min(n - 1, m)):
	b = b - a[i]
	ans = max(ans, (b + min((n - 1 - i) * k, m - 1 - i)) / (n - 1 - i))
print(ans)


(n, k, m) = map(int, input().split())
a = sorted(list(map(int, input().split())))
s = [0] * n
s[-1] = a[-1]
for i in range(n - 2, -1, -1):
	s[i] = s[i + 1] + a[i]
if len(a) != 1 and m != k and (len(set(a)) == 1):
	print((s[0] + m) / n)
elif m >= n:
	if n != 1:
		print(float(a[-1] + min(k, m - n + 1)))
	else:
		print(float(a[-1] + k))
else:
	ans = s[0] / n
	for i in range(k + 1):
		d = (s[m - i] + i) / (n - m + i)
		if d > ans:
			ans = d
	print(ans)


(n_super, max_increase, max_op) = list(map(int, input().strip().split()))
powers = list(map(int, input().strip().split()))
powers = sorted(powers)
curr_sum = sum(powers)
best_score = float('-inf')
for idx in range(n_super):
	n_remaining_hero = n_super - idx
	n_remaining_actions = max_op - idx
	if n_remaining_actions < 0:
		break
	this_score = curr_sum / n_remaining_hero + min(max_increase, n_remaining_actions / n_remaining_hero)
	if this_score > best_score:
		best_score = this_score
	curr_sum -= powers[idx]
print(best_score)


def main():
	[n, k, m] = list(map(int, input().split(' ')))
	ar = list(map(int, input().split(' ')))
	ar.sort()
	length = len(ar)
	prevSum = sum(ar)
	prev = sum(ar) / length
	maxAvg = prev
	while True:
		toadd = min(length * k, m)
		newAvg = (prevSum + toadd) / length
		if newAvg > maxAvg:
			maxAvg = newAvg
		popped = ar.pop(0)
		m -= 1
		length -= 1
		if length == 0 or m < 0:
			break
		prevSum = prevSum - popped
	print(str.format('{0:.20f}', maxAvg))
	return
main()


from math import sqrt
import heapq

def main():
	(n, k, m) = [int(x) for x in input().split(' ')]
	a = sorted([int(x) for x in input().split(' ')])
	suf_sum = [a[i] for i in range(n)]
	for i in range(n - 2, -1, -1):
		suf_sum[i] += suf_sum[i + 1]
	best = (sum(a) + min(m, k * n)) / n
	for i in range(n - 1):
		if i + 1 <= m:
			add = min(m - (i + 1), k * (n - (i + 1)))
			best = max(best, (suf_sum[i + 1] + add) / (n - (i + 1)))
	print('%.10f' % best)
main()


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
all = sum(a)
best = 0
for i in range(min(n, m + 1)):
	left = m - i
	ALL = all + min(left, k * (n - i))
	mid = ALL / (n - i)
	if mid > best:
		best = mid
	all -= a[i]
print(best)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
s = sum(a)
num = 0
for i in range(min(m + 1, n)):
	q = s + min((n - i) * k, m - i)
	num = max(num, q / (n - i))
	s -= a[i]
print(num)


(n, k, m) = [int(v) for v in input().split()]
powers = sorted([int(v) for v in input().split()])
total = sum(powers)
res = (total + min(m, n * k)) / n
for idx in range(min(m, n - 1)):
	total -= powers[idx]
	m -= 1
	n -= 1
	res = max(res, (total + min(m, n * k)) / n)
print(res)


(n, k, m) = map(int, input().split())
power = sorted(list(map(int, input().split())))
total = sum(power)
maxpower = (total + min(m, n * k)) / n
for i in range(min(n - 1, m)):
	total -= power[i]
	tmp = total + min(m - i - 1, (n - i - 1) * k)
	maxpower = max(maxpower, tmp / (n - i - 1))
print(maxpower)


(n, k, m) = map(int, input().split())
a = sorted(map(int, input().split()), reverse=True)
best = 0
summation = sum(a)
while n > 0 and m >= 0:
	best = max(best, (summation + min(m, k * n)) / n)
	summation -= a[-1]
	n -= 1
	m -= 1
	a.pop()
print(best)


(n, k, m) = list(map(int, input().split()))
l = list(map(int, input().split()))
res = 0
avg = sum(l) / n
s = sum(l)
l.sort()
for i in range(min(n, m + 1)):
	if i > 0:
		s -= l[i - 1]
	left = m - i
	temp = min(left, k * (n - i))
	res = max(res, (s + temp) / (n - i))
print(res)


from math import fsum
(n, k, m) = map(int, input().split())
(aa, lo, hi) = (sorted(map(float, input().split()), reverse=True), max(1, n - m), n + 1)
aa.append(0.0)
m -= n
while lo < hi:
	mid = (lo + hi) // 2
	if min(k * mid, m + mid) * (mid + 1) + fsum(aa[:mid]) < (aa[mid] + min(k * (mid + 1), m + mid + 1)) * mid:
		lo = mid + 1
	else:
		hi = mid
print((fsum(aa[:lo]) + min(k * lo, m + lo)) / lo)


(n, k, m) = map(int, input().split())
a = [int(i) for i in input().split()]
a.sort(reverse=True)
max_avg = 0
total = sum(a)
while n > 0 and m > -1:
	tmp = (total + min(n * k, m)) / n
	if max_avg < tmp:
		max_avg = tmp
	total -= a.pop()
	n -= 1
	m -= 1
print(max_avg)


(n, k, m) = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
hau = sum(A)
heks = (sum(A) + min(m, n * k)) / n
for i in range(n - 1):
	if m > 0:
		m -= 1
		hau -= A[i]
		heks = max(heks, (hau + min(m, (n - 1 - i) * k)) / (n - i - 1))
print(heks)


def my_min(x, y):
	if x > y:
		return y
	return x

def my_max(x, y):
	if x > y:
		return x
	return y
input1 = input().split(' ')
a = input().split(' ')
n = int(input1[0])
k = int(input1[1])
m = int(input1[2])
Sum = 0
a_l = len(a)
for i in range(a_l):
	a[i] = int(a[i])
	Sum += a[i]
a.sort()
r = my_min(n - 1, m)
ans = (Sum + my_min(m, n * k)) / n
for i in range(r):
	Sum -= a[i]
	ans = my_max(ans, (Sum + my_min(m - i - 1, k * (n - i - 1))) / (n - i - 1))
print(ans)


import sys
from atexit import register
from io import FileIO, StringIO
sys.stdin = StringIO(FileIO(0).read().decode())
input = lambda : sys.stdin.readline().rstrip('\r\n')
sys.stdout = StringIO()
register(lambda : FileIO(1, 'w').write(sys.stdout.getvalue().encode()))

def main():
	(n, k, m) = map(int, input().split())
	a = sorted(map(int, input().split()), reverse=True)
	pref_sums = [0] * n
	pref_sums[0] = a[0]
	for i in range(1, n):
		pref_sums[i] = pref_sums[i - 1] + a[i]
	print(max(((pref_sums[n - i - 1] + min(m - i, k * (n - i))) / (n - i) for i in range(min(m + 1, n)))))
main()


(n, k, m) = map(int, input().split())
A = sorted(list(map(int, input().split())))
list.reverse(A)
Sum = 0.0
Ans = 0.0
for i in range(n):
	Sum += A[i]
	t = n - i - 1
	if m >= n - i - 1:
		Ans = max(Ans, (Sum + min(m - t, (i + 1) * k)) / (i + 1))
print(Ans)


(n, k, m) = map(int, input().split())
x = list(map(int, input().split()))
a = 0
xx = set(x)
import math
nn = math.ceil(n / 2)
if len(xx) <= nn:
	if m > n:
		x = sorted(x, reverse=True)
		m = m - (n - 1)
		if m < 0:
			m = abs(m) + 1
			a = 0
			for i in range(0, m):
				a += x[i]
			print(a / m)
		else:
			print(x[0] + min(m, k))
	else:
		x = sorted(x)
		c = n
		maxx = x[n - 1]
		t = x.count(maxx)
		if t >= nn:
			for i in range(0, n):
				if x[i] == maxx:
					a += x[i]
				elif m > 0:
					c -= 1
					m -= 1
			a += min(k * c, m)
			print(a / c)
		else:
			a = sum(x) + min(k * n, m)
			print(a / n)
else:
	x = sorted(x, reverse=True)
	m = m - (n - 1)
	if m < 0:
		m = abs(m) + 1
		a = 0
		for i in range(0, m):
			a += x[i]
		print(a / m)
	else:
		print(x[0] + min(m, k))


(n, k, m) = map(int, input().split())
arr = [int(x) for x in input().split()]
k = min(k, m)
arr.sort()
s = [sum(arr)]
for i in range(1, len(arr)):
	s.append(s[i - 1] - arr[i - 1])
r = [0] * len(s)
for i in range(len(s)):
	f = m - i
	if f < 0:
		break
	r[i] = s[i] + min(k * (n - i), f)
	r[i] /= n - i
print(max(r))


(n, k, m) = list(map(int, input().split()))
l = sorted(list(map(int, input().split())))
tot = 0
prefix = []
ans = 0.0
for i in range(n):
	tot += l[i]
	prefix.append(tot)
prefix.insert(0, 0)
for i in range(n + 1):
	if m > 0:
		t = prefix[n] - prefix[i]
		if i != 0:
			m -= 1
		if m <= (n - i) * k:
			t += m
		else:
			t += (n - i) * k
		if n - i != 0:
			t = 1.0 * t / (n - i)
			if ans < t:
				ans = t
print('%0.20f' % ans)


(n, k, m) = map(int, input().split())
a = sorted(map(int, input().split()))
s = sum(a)
ans = s / n
for i in range(min(n, m + 1)):
	x = s + min((n - i) * k, m - i)
	ans = max(ans, x / (n - i))
	s -= a[i]
print('%.17f' % ans)


(n, k, m) = [int(x) for x in input().split()]
L = [int(x) for x in input().split()]
L.sort(reverse=True)
T = [0]
for i in range(n):
	T.append(T[-1] + L[i])
best = 0
for i in range(1, n + 1):
	if n - i <= m:
		best = max(best, (T[i] + min(m - n + i, k * i)) / i)
print(best)


from sys import stdin, stdout

def inp():
	return stdin.readline()

def minp():
	return map(int, stdin.readline().rstrip().split())

def linp():
	return list(minp())

def main():
	(n, k, m) = minp()
	lst = linp()
	lst.sort()
	l = 0
	if n * k > m:
		ss = m
	else:
		ss = n * k
	SUM = sum(lst)
	d = (SUM + ss) / n
	ll = [d]
	for i in range(n - 1):
		SUM -= lst[i]
		lst[i] = 0
		m -= 1
		l += 1
		if m > (n - l) * k:
			ss = (n - l) * k
		else:
			ss = m
		if (SUM + ss) / (n - l) > d:
			d = (SUM + ss) / (n - l)
		if m < 1:
			m = 0
			break
	if m > (n - l) * k:
		ad = (n - l) * k
	else:
		ad = m
	print(max((SUM + ad) / (n - l), d))
main()


import os
import sys
from math import *
from collections import *
from bisect import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
ALPHA = 'abcdefghijklmnopqrstuvwxyz/'
M = 1000000007
EPS = 1e-06

def Ceil(a, b):
	return a // b + int(a % b > 0)

def value():
	return tuple(map(int, input().split()))

def array():
	return [int(i) for i in input().split()]

def Int():
	return int(input())

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]
(n, k, m) = value()
a = sorted(array())
num = sum(a)
den = n
extra = min(m, den * k)
ans = (num + extra) / den
for i in range(m):
	if i < n - 1:
		m -= 1
		den -= 1
		num -= a[i]
		extra = min(m, den * k)
		ans = max((num + extra) / den, ans)
print(ans)


import sys
input = sys.stdin.readline
(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
s = sum(a)
ans = (min(k * n, m) + s) / n
for i in range(n - 1):
	if i + 1 > m:
		break
	s -= a[i]
	ans = max(ans, (min(k * (n - i - 1), m - i - 1) + s) / (n - i - 1))
print(ans)


(n, k, m) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
suml = sum(l)
mean = 0
if n * k > m:
	maxIncrease = m
else:
	maxIncrease = n * k
mean = (suml + maxIncrease) / n
sumP = suml
maxIncrease = 0
for i in range(1, min(n - 1, m) + 1):
	if (n - i) * k > m - i:
		maxIncrease = m - i
	else:
		maxIncrease = (n - i) * k
	sumP = sumP - l[i - 1]
	mean = max(mean, (sumP + maxIncrease) / (n - i))
print(mean)


from sys import stdin
(n, m, k) = list(map(int, stdin.readline().strip().split()))
s = list(map(int, stdin.readline().strip().split()))
s.sort()
acum = [0]
for i in range(n - 1, -1, -1):
	acum.append(acum[-1] + s[i])
acum.reverse()
acum.pop()
y = min(n * m, k)
ans = (sum(s) + y) / n
for i in range(min(n - 1, k)):
	k -= 1
	y = min((n - i - 1) * m, k)
	ans = max(ans, (acum[i + 1] + y) / (n - i - 1))
print(ans)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
s = sum(a)
avg = 0
for i in range(min(m + 1, n)):
	avg = max(avg, (s + min(k * (n - i), m - i)) / (n - i))
	s -= a[i]
print(avg)


import collections
import itertools
from functools import reduce
mod = 10 ** 9 + 7

def permutationbysum():
	for _ in range(int(input())):
		(num, l, r, achieve) = map(int, input().split())
		k = r - l + 1
		if k * (k + 1) // 2 <= achieve <= k * (num * 2 + 1 - k) // 2:
			outpos = r % num
			inpos = l - 1
			ans = [0] * num
			for i in range(num, 0, -1):
				if achieve - i > 0 or (achieve - i == 0 and inpos == r - 1):
					achieve -= i
					ans[inpos] = i
					inpos += 1
				else:
					ans[outpos] = i
					outpos += 1
					outpos %= num
			print(*ans)
		else:
			print(-1)

def peaks():
	for _ in range(int(input())):
		(num, peak) = map(int, input().split())
		pos = 1
		rpos = num
		ans = []
		now = 0
		if num == 1:
			if not peak:
				print(1)
			else:
				print(-1)
			continue
		if num == 2:
			if peak:
				print(-1)
			else:
				print(1, 2)
			continue
		added = 0
		while rpos + 1 != pos:
			if not peak:
				while pos <= rpos:
					ans.append(pos)
					pos += 1
				break
			if not now:
				ans.append(pos)
				pos += 1
			else:
				ans.append(rpos)
				rpos -= 1
				if num - added != 1:
					peak -= 1
			added += 1
			now = 1 - now
		if peak:
			print(-1)
			continue
		print(*ans)
import sys
input = sys.stdin.readline

def addone():
	for _ in range(int(input())):
		(num, changes) = input().split()
		l = collections.deque(sorted([int(i) for i in num]))
		perm = collections.deque()
		changes = int(changes)
		cd = 0
		ans = len(num)
		while True:
			nextnum = l.pop()
			while perm and perm[-1] == nextnum:
				l.append(perm.pop())
			c = 10 - nextnum - cd
			changes -= c
			cd += c
			if changes >= 0:
				if not c:
					perm.appendleft(1 - cd)
					l.appendleft(-cd)
				else:
					l.appendleft(1 - cd)
					l.appendleft(-cd)
				ans += 1
			else:
				break
		print(ans % 1000000007)
import math

def andsequences():

	def mapping(num):
		nonlocal mnum
		nonlocal c
		num = int(num)
		if num < mnum:
			mnum = num
			c = 1
		elif num == mnum:
			c += 1
		return num
	mod = 1000000007
	for _ in range(int(input())):
		mnum = float('inf')
		c = 0
		num = int(input())
		l = list(map(mapping, input().split()))
		for i in l:
			if mnum & i != mnum:
				print(0)
				break
		else:
			if c == 1:
				print(0)
			else:
				print(math.factorial(num - 2) * (c - 1) * c % mod)

def numberdigit():
	n = 10 ** 5 * 2
	l = [0] * 11
	mod = 10 ** 9 + 7
	l[0] = l[1] = l[2] = l[3] = l[4] = l[5] = l[6] = l[7] = l[8] = 2
	l[9] = 3
	l[10] = 4
	for i in range(11, n):
		l.append((l[i - 10] + l[i - 9]) % mod)
	for _ in range(int(input())):
		(num, c) = input().split()
		c = int(c)
		ans = 0
		for i in num:
			i = int(i)
			if 10 - i > c:
				ans += 1
			else:
				ans += l[c - (10 - i)]
		print(ans % mod)

def mushroom():
	(people, t1, t2, percent) = map(int, input().split())
	l = []
	percent = 1 - percent * 0.01
	for i in range(1, people + 1):
		(s, s1) = map(int, input().split())
		l.append([i, max(s * t1 * percent + s1 * t2, s1 * t1 * percent + s * t2)])
	l.sort(key=lambda x: x[1], reverse=True)
	for i in l:
		i[1] = '{:.2f}'.format(i[1])
		print(*i)

def escape():
	prins = int(input())
	dra = int(input())
	start = int(input())
	pack = int(input())
	c = int(input())
	speeddiff = dra - prins
	if speeddiff <= 0:
		return 0
	pd = start * prins
	ans = 0
	while pd < c:
		hs = pd / speeddiff
		pd += prins * hs
		if pd >= c:
			break
		time = pd / dra
		time += pack
		pd += prins * time
		ans += 1
	return ans

def perm():

	def high(n, k):
		return k * (2 * n - k + 1) // 2

	def low(k):
		return k * (k + 1) // 2
	for _ in range(int(input())):
		(num, lef, rig, s) = map(int, input().split())
		k = rig - lef + 1
		(rig, lef) = (rig - 1, lef - 1)
		if not high(num, k) >= s >= low(k):
			print(-1)
			continue
		l = [0] * num
		lp = lef
		rp = lef - 1
		for i in range(num, 0, -1):
			if high(i, k) >= s and s - i >= low(k - 1) and k:
				l[lp] = i
				lp += 1
				s -= i
				k -= 1
			else:
				l[rp] = i
				rp -= 1
		if k:
			print(-1)
		else:
			print(*l)

def newcom():
	for _ in range(int(input())):
		(days, price) = map(int, input().split())
		dl = input().split()
		worth = input().split()
		worth.append(0)
		ans = float('inf')
		req = 0
		left = 0
		for i in range(days):
			a = int(dl[i])
			w = int(worth[i])
			ans = min(ans, req + max(0, price - left + a - 1) // a)
			ns = max(0, w - left + a - 1) // a
			req += ns + 1
			left += a * ns - w
		print(ans)

def perfectsq():
	for _ in range(int(input())):
		n = input()
		for i in input().split():
			sq = math.sqrt(int(i))
			if sq != int(sq):
				print('YES')
				break
		else:
			print('NO')

def and0big():
	for _ in range(int(input())):
		(l, k) = map(int, input().split())
		print(l ** k % mod)
import math

def mod1p():
	n = int(input())
	ans = dict()
	p = 1
	for i in range(1, n):
		if math.gcd(i, n) == 1:
			ans[str(i)] = True
			p = p * i % n
	if p == 1:
		print(len(ans))
		print(' '.join(ans.keys()))
	else:
		ans.pop(str(p))
		print(len(ans))
		print(' '.join(ans.keys()))

def shorttask():
	num = 10000100
	l = [-1] * (num + 2)
	s = [-1] * (num + 2)
	l[1] = 1
	for i in range(2, int(math.sqrt(num + 1)) + 2):
		if l[i] == -1:
			l[i] = i
			for x in range(i * i, num + 1, i):
				if l[x] == -1:
					l[x] = i
	s[1] = 1
	for i in range(2, num + 1):
		if l[i] == -1:
			l[i] = i
			s[i] = i + 1
		else:
			i1 = i
			s[i] = 1
			while i1 % l[i] == 0:
				i1 //= l[i]
				s[i] = s[i] * l[i] + 1
			s[i] *= s[i1]
	ans = [-1] * (num + 1)
	for i in range(num, 0, -1):
		if s[i] < num:
			ans[s[i]] = i
	for _ in range(int(input())):
		print(ans[int(input())])

def review():
	for _ in range(int(input())):
		n = int(input())
		ans = 0
		for i in input().split():
			i = int(i)
			if i == 1 or i == 3:
				ans += 1
		print(ans)

def GCDleng():
	po10 = [0] * 11
	po10[1] = 1
	for i in range(2, 11):
		po10[i] = po10[i - 1] * 10
	for _ in range(int(input())):
		(n, n1, res) = map(int, input().split())
		print(po10[n], po10[n1] + po10[res])

def anothercarddeck():
	(n, q) = map(int, input().split())
	l = input().split()
	d = {l[i]: i for i in range(n - 1, -1, -1)}
	ans = []
	for i in input().split():
		now = d[i]
		ans.append(now + 1)
		for key in d:
			if d[key] < now:
				d[key] += 1
		d[i] = 0
	print(*ans)

def mincoststring():
	(n, letters) = map(int, input().split())
	l = [chr(i + 97) for i in range(letters)]
	ans = []
	real = letters - 1
	if not n:
		print(*ans, sep='')
		return
	if n == 1:
		print(*ans, sep='', end='')
		print(l[1 % (real + 1)])
		return
	while n:
		for i in range(len(l)):
			for i1 in range(i, len(l)):
				if i1 != real:
					ans.append(l[i1])
					ans.append(l[i])
					n -= 2
				else:
					ans.append(l[i1])
					n -= 1
				if not n:
					print(*ans, sep='')
					return
				if n == 1:
					print(*ans, sep='', end='')
					print(l[(i1 + 1) % (real + 1)])
					return
	print(*ans)

def mincost2():
	(n, letters) = map(int, input().split())
	l = [chr(i + 97) for i in range(letters)]
	comb = []
	if letters == 1 or n == 1:
		print('a' * n)
		return
	for i in range(letters):
		for i1 in range(i, letters):
			comb.append(l[i1] + l[i])
	lc = len(comb)
	while True:
		for i in range(lc):
			if ord(comb[i][0]) - 97 == letters - 1:
				n -= 1
				print(comb[i][0], end='')
			else:
				n -= 2
				print(comb[i], end='')
			if n == 1:
				pos = ord(comb[i][0]) - 97 + 1
				print(l[pos % letters])
				return
			if not n:
				return

def Tittat():
	for _ in range(int(input())):
		(n, k) = map(int, input().split())
		l = list(map(int, input().split()))
		for i in range(n):
			if not k:
				break
			while k and l[i]:
				l[i] -= 1
				l[-1] += 1
				k -= 1
		print(*l)

def xorq2():
	for _ in range(int(input())):
		n = int(input())
		s = 0
		num = -1
		nc = 0
		c = 0
		for i in input().split():
			i = int(i)
			s ^= i
			c += 1
			if num == -1 and s == i:
				num = s
				s = 0
				nc += c
				c = 0
			if num != -1 and (s == num or not s):
				s = 0
				nc += c
				c = 0
		print(['NO', 'YES'][nc == n])

def xorq2re():
	n = int(input())
	s = input().split()
	xor = 0
	for i in range(n):
		s[i] = int(s[i])
		xor ^= s[i]
	if not xor:
		print('YES')
	else:
		new = 0
		ans = 0
		for i in s:
			new ^= i
			if new == xor:
				new = 0
				ans += 1
		print(['NO', 'YES'][ans > 1])
import sys
sys.setrecursionlimit(2300)

def q3partition():

	def partition():
		if tol % 2:
			return 0
		up = tol
		rec = [[False] * (up + 2) for _ in range(n + 1)]
		rec[0][0] = True
		for i in range(1, n + 1):
			v = l[i - 1]
			for j in range(up + 1):
				if rec[i - 1][j]:
					if v + j <= up:
						rec[i][j + v] = True
					rec[i][j] = True
		return rec[n][tol // 2]

	def ints(x):
		nonlocal tol
		nonlocal gcf
		x = int(x)
		tol += x
		gcf = math.gcd(gcf, x) if gcf != float('inf') else x
		return x
	n = int(input())
	tol = 0
	gcf = float('inf')
	l = list(map(ints, input().split()))
	if partition():
		pos = 1
		for i in l:
			if i // gcf % 2:
				print(1)
				print(pos)
				return
			pos += 1
	else:
		print(0)

def permu(n, r):
	return math.factorial(n) // math.factorial(n - r)

def comb(n, r):
	return math.factorial(n) // math.factorial(r) * math.factorial(n - r)

def calc():
	n = int(input())
	ans = permu(n, n)
	for i in range(1, n + 1):
		ans -= comb(n, i)
	print(ans)

def order():
	for _ in range(int(input())):
		n = int(input())
		odd = []
		even = []
		for i in input().split():
			i = int(i)
			if i % 2:
				odd.append(i)
			else:
				even.append(i)
		print(*odd + even)

def TMTdoc():
	n = int(input())
	l = input().rstrip()
	tts = 0
	tms = 0
	for i in l:
		if i == 'T':
			tts += 1
		else:
			tms += 1
	if tms * 2 == tts:
		nowts = 0
		nowms = 0
		for i in l:
			if i == 'T':
				nowts += 1
			else:
				nowms += 1
				if nowts >= nowms and tms - nowms + 1 <= tts - nowts:
					continue
				return 'NO'
	else:
		return 'NO'
	return 'YES'

def relayrace():

	def solve(n):
		if n:
			s = -1
		else:
			s = 1
		nowmax = -float('inf')
		nowmin = -nowmax
		ans = 0
		for (i, v) in sorted(l, key=lambda x: (x[1], s * int(x[0])), reverse=True):
			i = int(i)
			if i > nowmax:
				nowmax = i
			if i < nowmin:
				nowmin = i
			ans += v * (nowmax - nowmin)
		return ans
	n = int(input())
	l = -1
	ans = 0
	for i in sorted(input().split(), key=lambda x: int(x)):
		if l == -1:
			l = int(i)
		else:
			ans += int(i) - l
	return ans

def relayraces():
	n = int(input())
	l = sorted(map(int, input().split()))
	minv = float('INF')
	minpos = 0
	for i in range(len(l)):
		if i > 0 and 0 <= l[i] - l[i - 1] <= minv:
			minv = l[i] - l[i - 1]
			minpos = i
		if i < n - 1 and l[i + 1] - l[i] <= minv:
			minv = l[i + 1] - l[i]
			minpos = i
	lpos = minpos - 1
	rpos = minpos + 1
	ans = 0
	while lpos >= 0 and rpos < n:
		diffl = -(l[lpos] - l[minpos])
		diffr = l[rpos] - l[minpos]
		if diffl < diffr:
			minpos = lpos
			lpos -= 1
			ans += diffl
		else:
			minpos = rpos
			rpos += 1
			ans += diffr
	if lpos < 0:
		m = l[0]
		for i in range(rpos, n):
			ans += l[i] - m
	else:
		h = l[-1]
		for i in range(minpos, -1, -1):
			ans += h - l[i]
	return ans

def relayracess():

	def recur(l, r):
		if l == r:
			return 0
		if d[l, r] != -1:
			return d[l, r]
		ans = nums[r] - nums[l] + min(recur(l + 1, r), recur(l, r - 1))
		d[l, r] = ans
		return ans
	d = collections.defaultdict(lambda : -1)
	n = int(input())
	nums = sorted(map(int, input().split()))
	return recur(0, n - 1)

def relayracesss():
	n = int(input())
	l = sorted(map(int, input().split()))
	dp = [[0] * n for _ in range(n)]
	for i in range(n - 2, -1, -1):
		for i1 in range(i + 1, n):
			dp[i][i1] = l[i1] - l[i] + min(dp[i + 1][i1], dp[i][i1 - 1])
	return dp[0][n - 1]

def relayracessss():
	n = int(input())
	l = sorted(map(int, input().split()))
	dp = [0] * n
	for le in range(n - 2, -1, -1):
		for ri in range(le + 1, n):
			dp[ri] = l[ri] - l[le] + min(dp[ri], dp[ri - 1])
	return dp[-1]

def binli():
	n = int(input())
	n2 = n * 2
	s = input().rstrip()
	s1 = input().rstrip()
	s2 = input().rstrip()
	posl = [0, 0, 0]
	ans = ''
	while max(posl) < n2:
		l = [[], []]
		l[int(s[posl[0]])].append(0)
		l[int(s1[posl[1]])].append(1)
		l[int(s2[posl[2]])].append(2)
		if len(l[0]) >= 2:
			for i in l[0]:
				posl[i] += 1
			ans += '0'
		else:
			for i in l[1]:
				posl[i] += 1
			ans += '1'
	if posl[0] == n2:
		if posl[1] >= posl[2]:
			ans += s1[posl[1]:]
		else:
			ans += s2[posl[2]:]
	elif posl[1] == n2:
		if posl[0] >= posl[2]:
			ans += s[posl[0]:]
		else:
			ans += s2[posl[2]:]
	elif posl[0] >= posl[1]:
		ans += s[posl[0]:]
	else:
		ans += s1[posl[1]:]
	print(ans)

def almostsort():
	(n, k) = map(int, input().split())
	ul = 2 ** (n - 1)
	if k > ul:
		return [-1]
	permen = []
	bi = bin(k - 1)[2:]
	if bi == '0':
		return range(1, n + 1)
	pos = n - len(bi)
	ans = list(range(1, pos))
	for i in bi:
		permen.append(pos)
		if not int(i):
			ans += permen[::-1]
			permen = []
		pos += 1
	permen.append(n)
	ans += permen[::-1]
	return ans

def q1_2050():
	for i in range(int(input())):
		s = int(input())
		if s % 2050:
			print(-1)
		else:
			ab = 2050
			while ab <= s:
				ab *= 10
			ab //= 10
			c = 0
			while s and s != 1:
				c += s // ab
				s = s % ab
				while s != 1 and s and (s < ab):
					ab //= 10
			print(c)

def q2jog():
	(n, m) = map(int, input().split())
	sortbyval = []
	rowsv = [collections.defaultdict(int) for _ in range(n)]
	for row in range(n):
		for i in input().split():
			i = int(i)
			sortbyval.append([i, row])
			rowsv[row][i] += 1
	sortbyval.sort(key=lambda x: x[0])
	larl = []
	for i in range(0, n * m, m):
		larl.append(sortbyval[i:i + m])
	ans = [[0] * m for _ in range(n)]
	person = 0
	for i in larl:
		for (v, pos) in i:
			ans[pos][person] = v
			rowsv[pos][v] -= 1
			person += 1
			if person == m:
				break
		else:
			continue
		break
	for r in range(n):
		for c in range(m):
			if not ans[r][c]:
				for key in list(rowsv[r].keys()):
					if not rowsv[r][key]:
						rowsv[r].pop(key)
						continue
					rowsv[r][key] -= 1
					ans[r][c] = key
					break
	for i in ans:
		print(*i)

def q3fillomino(n, inp):

	def gorow():
		nonlocal nowp
		nonlocal col
		nonlocal totake
		t = 0
		if nowp and col < n and totake and (not l[col][nowp - 1]):
			for back in range(nowp, -1, -1):
				if l[col][back]:
					nowp += 1
					col += 1
					return t
				if not totake:
					return t
				l[col][back] = i
				totake -= 1
				nowp -= 1
				t = 1
			nowp += 1
			col += 1
		return t
	l = [[0] * i for i in range(1, n + 1)]
	p = 0
	for i in inp:
		totake = int(i)
		nowp = p
		col = p
		while col < n:
			if not totake:
				break
			for _ in range(n - p):
				if not gorow():
					break
			if not totake or col == n or nowp == n:
				break
			l[col][nowp] = i
			totake -= 1
			col += 1
		p += 1
	for i in l:
		print(*i)

def q3fillominoclear(n, inp):
	l = [[0] * i for i in range(1, n + 1)]
	p = 0
	for i in inp:
		take = int(i) - 1
		l[p][p] = i
		(x, y) = (p, p)
		while take:
			if y and (not l[x][y - 1]):
				y -= 1
			else:
				x += 1
			l[x][y] = i
			take -= 1
		p += 1
	for i in l:
		print(*i)

def q4explor():

	def gen(r, c):
		res = float('inf')
		if r:
			res = min(res, his[r - 1][c] + 2 * colstep[r - 1][c])
		if r < rows - 1:
			res = min(res, his[r + 1][c] + 2 * colstep[r][c])
		if c:
			res = min(res, his[r][c - 1] + 2 * rowstep[r][c - 1])
		if c < cols - 1:
			res = min(res, his[r][c + 1] + 2 * rowstep[r][c])
		return res
	(rows, cols, k) = map(int, input().split())
	if k % 2:
		for i in range(rows):
			print(*[-1] * cols)
		return
	rowstep = [list(map(int, input().split())) for _ in range(rows)]
	colstep = [list(map(int, input().split())) for _ in range(rows - 1)]
	his = [[0] * cols for _ in range(rows)]
	for _ in range(k // 2):
		temp = [[gen(r, c) for c in range(cols)] for r in range(rows)]
		his = temp
	for i in his:
		print(*i)

def cvacations():

	def de(v):
		nonlocal last
		if v == 2:
			last = 2
		elif v == 1:
			last = 1
	n = int(input())
	ans = 0
	last = 0
	l = input().split()
	for i1 in range(n):
		i = int(l[i1])
		if not i:
			last = 0
			ans += 1
			continue
		if i == 1:
			if last != 2:
				last = 2
				continue
			ans += 1
			last = 0
		elif i == 2:
			if last != 1:
				last = 1
				continue
			ans += 1
			last = 0
		elif not last:
			if i1 < n - 1:
				de(int(l[i1 + 1]))
				if int(l[i1 + 1]) == 3:
					for pos in range(i1 + 2, n):
						if l[pos] != 3:
							r = l[pos]
							break
					else:
						last = 1
						continue
					de(r)
			else:
				break
		elif last == 1:
			last = 2
		elif last == 2:
			last = 1
	return ans

def brackets():
	s = input().rstrip()
	(lpos, rpos) = (0, len(s) - 1)
	ans = []
	while lpos + 1 <= rpos:
		if s[lpos] == '(':
			if s[rpos] == ')':
				ans.append(lpos + 1)
				ans.append(rpos + 1)
				lpos += 1
				rpos -= 1
			else:
				rpos -= 1
		else:
			lpos += 1
	if ans:
		print(1)
		print(len(ans))
		print(*sorted(ans))
	else:
		print(0)

def In():
	return map(int, input().split())

def complibook():
	(n, q) = In()
	nums = list(In())
	for _ in range(q):
		(l, r, x) = In()
		num = nums[x - 1]
		les = 0
		for i in range(l - 1, r):
			if nums[i] < num:
				les += 1
		print(['No', 'Yes'][les + l - 1 == x - 1])

def bstr():
	for _ in range(int(input())):
		(n, k) = In()
		now = 1
		times = 2
		while k > now:
			k -= now
			now += 1
			times += 1
		fir = n - times
		sec = n - k
		for i in range(n):
			if i == fir or i == sec:
				print('b', end='')
			else:
				print('a', end='')
		print()

def avgsuper():
	(n, k, oper) = In()
	l = sorted(In(), reverse=True)
	nowavg = sum(l) / n
	(addpos, addnum) = (0, 0)
	for i in range(oper):
		if n == 1 and addpos != 0:
			break
		new = (nowavg * n - l[n - 1]) / max(n - 1, 1)
		if 1 / n > new - nowavg and addpos < n:
			addnum += 1
			if addnum >= k:
				addpos += 1
				addnum = 0
			nowavg += 1 / n
		else:
			nowavg = new
			n -= 1
	print(nowavg)

def avgsuper2():
	(n, k, oper) = In()
	l = sorted(In(), reverse=True)
	prefix = [0] * (n + 1)
	for i in range(1, n + 1):
		prefix[i] = l[i - 1] + prefix[i - 1]
	prefix.pop(0)
	ans = 0
	for i in range(n - 1, max(-1, n - oper - 2), -1):
		ans = max(ans, (prefix[i] + min(k * (i + 1), oper - (n - i - 1))) / (i + 1))
	return ans
print(avgsuper2())


import sys
sys.setrecursionlimit(200000)
input = sys.stdin.readline
(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort(key=lambda x: -x)
go = sum(a)
ans = (go + min(n * k, m)) / n
for i in range(n - 1):
	ke = a.pop()
	m -= 1
	go -= ke
	if m < 0:
		break
	ans = max(ans, (go + min((n - 1 - i) * k, m)) / (n - 1 - i))
print(ans)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
d = [0]
for i in range(n):
	d.append(d[-1] + a[i])
ans = d[n] / n
for i in range(min(n, m + 1)):
	ans = max(ans, (d[n] - d[i] + min((n - i) * k, m - i)) / (n - i))
print(ans)


(n, k, m) = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sm = 0
cl = [0]
for x in a:
	sm += x
	cl.append(sm)

def func(i):
	return (cl[-1] - cl[i] + min(k * (n - i), m - i)) / (n - i)
mx = 0
for i in range(min(n - 1, m) + 1):
	res = func(i)
	if res > mx:
		mx = res
print(mx)


(n, k, m) = map(int, input().split())
a = [int(i) for i in input().split()]
a.sort()
rs = sum(a)
cnt = n
for i in range(n):
	if cnt == 1 or (rs + min(m, k * cnt)) / cnt > (rs - a[i] + min(m - 1, k * (cnt - 1))) / (cnt - 1) or m == 0:
		break
	else:
		rs -= a[i]
		cnt -= 1
		m -= 1
print((rs + min(m, k * cnt)) / cnt)


(n, k, m) = map(int, input().split())
a = [int(s) for s in input().split()]
a.sort()
q = sum(a)
ans = 0
for i in range(min(n, m + 1)):
	if m - i >= (n - i) * k:
		ans = max(ans, (q + (n - i) * k) / (n - i))
	else:
		ans = max(ans, (q + m - i) / (n - i))
	q -= a[i]
print(ans)


(num_heros, opt_ph, tot_opt) = map(int, input().split(' '))
pList = list(map(int, input().split(' ')))
pList = sorted(pList)
pLen = len(pList)
tot_sum = sum(pList)
max_val = 0
x = 0
while x < pLen and x <= tot_opt:
	val = (tot_sum + min(tot_opt - x, (pLen - x) * opt_ph)) / (pLen - x)
	if val > max_val:
		max_val = val
	tot_sum -= pList[x]
	x += 1
print(max_val)


(n, k, m) = map(int, input().split())
a = sorted(list(map(int, input().split())))
(ans, i, j, x) = (0, 0, 0, sum(a))
length = n
while i < n and j <= m:
	avg = (x + min((k * length, max(0, m - i)))) / length
	if avg > ans:
		ans = avg
	x -= a[i]
	length -= 1
	j += 1
	i += 1
print(ans)


(n, k, m) = map(int, input().split())
a = map(int, input().split())
b = sorted(a)
sum_b = sum(b)
len_b = len(b)
res = sum_b / len_b + min(m, len_b * k) / len_b
for i in range(min(m, n - 1)):
	sum_b -= b[i]
	len_b -= 1
	res = max(res, sum_b / len_b + min(m - i - 1, len_b * k) / len_b)
print(res)


a = [int(i) for i in input().split()]
n = a[0]
k = a[1]
m = a[2]
a = [int(i) for i in input().split()]
sum_a = sum(a)

def boost(q, energy):
	max_boost = energy
	if max_boost > k * q:
		max_boost = k * q
	return max_boost
max_boost = boost(n, m)
average = (sum_a + max_boost) / n
people = n
energy = m
a.sort()
for i in range(n):
	if people - 1 != 0 and energy - 1 != -1:
		max_boost = boost(people - 1, energy - 1)
		tmp_average = (sum_a - a[i] + max_boost) / (people - 1)
		if average <= tmp_average:
			energy -= 1
			people -= 1
			sum_a -= a[i]
			average = tmp_average
print(average)


import collections
import time
import os
import sys
import bisect
import heapq
(N, K, M) = map(int, input().split())
A = [int(x) for x in input().split()]
A.sort()
S = [0] * (N + 1)
for i in range(N - 1, -1, -1):
	S[i] = S[i + 1] + A[i]
ans = 0
for l in range(min(N, M + 1)):
	r = N - l
	incr = min(M - l, r * K)
	ans = max(ans, (S[l] + incr) / r)
print(ans)


(n, k, m) = map(int, input().split())
arr = map(int, input().split())
arr = sorted(arr, reverse=True)
sub_s = [0, arr[0]]
for e in arr[1:]:
	sub_s.append(sub_s[-1] + e)
M = -1
for i in range(0, min(n - 1, m) + 1):
	l_s = (sub_s[n - i] + min((n - i) * k, m - i)) / (n - i)
	M = max(l_s, M)
print(M)


def func(OpCount, n, k, s):
	if n is 1:
		return min(OpCount, k) + li[0]
	Max = (s + min(m, n * k)) / n
	SumOfM = 0
	for i in range(n - 1):
		if i >= m:
			break
		SumOfM = SumOfM + li[i]
		t = s - SumOfM + min(OpCount - (i + 1), (n - (i + 1)) * k)
		t = t / (n - (i + 1))
		Max = max(t, Max)
	return Max
t = input().split()
(n, k, m) = (int(t[0]), int(t[1]), int(t[2]))
t = input().split()
li = [int(x) for x in t]
li.sort()
x = func(m, n, k, sum(li))
print(x)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
s = 0
for i in range(n):
	s += a[i]
mx = (s + min(m, k * n)) / n
for i in range(min(m, n - 1)):
	s -= a[i]
	mx = max(mx, (s + min(m - 1 - i, k * (n - 1 - i))) / (n - i - 1))
print(round(mx, 6))


(n, k, m) = list(map(int, input().split()))
a = sorted(map(int, input().split()))
res = 0
sm = sum(a)
for ai in a:
	if m < 0:
		break
	if m < k * n:
		alt = (sm + m) / n
	else:
		alt = sm / n + k
	res = max(res, alt)
	n -= 1
	m -= 1
	sm -= ai
print(res)


(n, k, m) = map(int, input().split())
players = list(map(int, input().split()))
players.sort()
s = sum(players)
ans = 0
for i in range(n):
	if i <= m:
		gain = min(m - i, k * (n - i))
		avg = (s + gain) / (n - i)
		if avg > ans:
			ans = avg
	else:
		break
	s -= players[i]
print(ans)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
(n, m, k) = map(int, input().split())
a = list(map(int, input().split()))
a.sort(reverse=True)
s = [] + a
if m * n < k:
	s = a[:max(1, n - k + m * n)]
s1 = (sum(s) + min(m * len(s), k)) / len(s)
if k >= n - 1:
	ind = n - 1 - a[::-1].index(max(a))
	l = a[:max(n - k, ind + 1)]
	sd = min(m * len(l), k - (n - len(l)))
	l1 = a[0]
	k -= n - 1
	l1 += min(k, m)
	print(max(s1, l1, (sum(l) + sd) / len(l)))
else:
	ind = n - 1 - a[::-1].index(max(a))
	l = a[:max(n - k, ind + 1)]
	sd = k - (n - len(l))
	l1 = a[:n - k]
	s2 = sum(l1) / (n - k)
	print(max(s1, s2, (sum(l) + sd) / len(l)))


(n, k, m) = [int(x) for x in input().split()]
powers = sorted([int(x) for x in input().split()])
sums = sum(powers)
avg = 0
for i in range(min(m + 1, n)):
	curr_max = sums + min((n - i) * k, m - i)
	avg = max(avg, curr_max / (n - i))
	sums -= powers[i]
print(avg)


import sys
from sys import stdin, stdout
import bisect
import math
import heapq

def modinv(n, p):
	return pow(n, p - 2, p)

def cin():
	return map(int, sin().split())

def ain():
	return list(map(int, sin().split()))

def sin():
	return input()

def inin():
	return int(input())
import math

def Divisors(n):
	l = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
	return l

def main():
	(n, k, m) = cin()
	a = ain()
	x = sum(a)
	a.sort()
	ans = (x + min(m, n * k)) / n
	for i in range(1, n):
		x -= a[i - 1]
		f = (x + min(m - i, (n - i) * k)) / (n - i)
		ans = max(ans, f)
		if m - i == 0:
			break
	print('%0.9f' % ans)
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
import sys

class ostream:

	def __lshift__(self, a):
		sys.stdout.write(str(a))
		return self
cout = ostream()
endl = '\n'

def readnumbers(zero=0):
	conv = ord if py2 else lambda x: x
	A = []
	numb = zero
	sign = 1
	i = 0
	s = sys.stdin.buffer.read()
	try:
		while True:
			if s[i] >= b'0'[0]:
				numb = 10 * numb + conv(s[i]) - 48
			elif s[i] == b'-'[0]:
				sign = -1
			elif s[i] != b'\r'[0]:
				A.append(sign * numb)
				numb = zero
				sign = 1
			i += 1
	except:
		pass
	if s and s[-1] >= b'0'[0]:
		A.append(sign * numb)
	return A
main()


import sys
(n, k, m) = [int(i) for i in input().split(' ')]

def helper(pows, k, m):
	res = -sys.maxsize
	pref = [0]
	for i in range(len(pows)):
		pref.append(pref[-1] + pows[i])
	if len(pows) == 1:
		return pows[0] + k
	for i in range(min(len(pows), m + 1)):
		total = m - i
		if (len(pows) - i) * k <= total:
			res = max(res, (pref[-1] - pref[i] + (len(pows) - i) * k) / (len(pows) - i))
		else:
			res = max(res, (pref[-1] - pref[i] + total) / (len(pows) - i))
	return res
pows = [int(i) for i in input().split(' ')]
pows.sort()
print(helper(pows, k, m))


(n, k, m) = map(int, input().split())
a = [i for i in map(int, input().split())]
a.sort()
total = sum(a)
ans = 0
i = 0
while i < n and i <= m:
	r = n - i
	ans = max(ans, (total + min(r * k, m - i)) / r)
	total -= a[i]
	i += 1
print('%.18f' % ans)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
total = sum(a)
best = (total + min(n * k, m)) / n
for i in range(n - 1):
	m -= 1
	if m < 0:
		break
	rem = n - i - 1
	total -= a[i]
	val = (total + min(rem * k, m)) / rem
	best = max(best, val)
print(best)


(n, k, m) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
s = sum(arr)
i = 0
ans = -1
if n == 1:
	print(arr[0] + min(k, m))
else:
	elements = n
	while i < n - 1 and m > 0:
		avg1 = s + min(elements * k, m)
		avg1 = avg1 / elements
		avg2 = s - arr[i] + min((elements - 1) * k, m - 1)
		avg2 = avg2 / (elements - 1)
		if avg1 >= avg2:
			ans = max(avg1, ans)
		else:
			ans = max(avg2, ans)
		s -= arr[i]
		elements -= 1
		m -= 1
		i += 1
	print(ans)


(n, k, m) = map(int, input().split())
arr = sorted(list(map(int, input().split())))
csum = [0]
for i in arr:
	csum.append(csum[-1] + i)

def f(i):
	return (csum[-1] - csum[i] + min(m - i, k * (n - i))) / (n - i)
max = 0
for i in range(min(m + 1, n)):
	if f(i) > max:
		max = f(i)
print(max)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
res = 0
if m < n:
	res = (sum(a) + m) / n
	for i in range(1, m + 1):
		res = max(res, (sum(a[i:]) + (m - i)) / (n - i))
else:
	res = a[-1] + min(m - n + 1, k)
print(res)


(n, k, m) = map(int, input().split())
aa = [int(i) for i in input().split()]
aa.sort()
ss = sum(aa)
maxi = (ss + min(n * k, m)) / n
for i in range(1, min(m + 1, n)):
	ss -= aa[i - 1]
	left = m - i
	can_add = (n - i) * k
	to_add = min(left, can_add)
	maxi = max(maxi, (ss + to_add) / (n - i))
print(maxi)


(n, k, m) = list(map(int, input().split()))
a = list(map(int, input().split()))
a = list(sorted(a))
s = [0] * n
s[0] = a[0]
for i in range(1, n):
	s[i] = s[i - 1] + a[i]
S = s[n - 1]
R = (S + min(k * n, m)) / n
for i in range(min(m, n - 1)):
	S = s[n - 1] - s[i]
	R = max((S + min(m - i - 1, k * (n - i - 1))) / (n - i - 1), R)
print(R)


(n, k, m) = map(int, input().split())
power_list = list(map(float, input().split()))
power_list.sort()
sum_list = [0]
for i in range(n):
	sum_list.append(sum_list[i] + power_list[i])
ans = -1.0
for i in range(min(m + 1, n)):
	ans = max(ans, float(sum_list[n] - sum_list[i] + float(min(m - i, (n - i) * k))) / float(n - i))
print('{:.10f}'.format(ans))


(n, m, k) = [int(x) for x in input().split()]
sup = [int(x) for x in input().split()]
summa = 0
sup.sort()
total = []
counter = len(sup)
flag = False
for item in sup:
	summa += item
a = (summa + min(m * counter, k)) / counter
total.append(a)
for item in sup:
	k -= 1
	if k >= 0:
		if counter > 1:
			summa -= item
			counter -= 1
			a = (summa + min(m * counter, k)) / counter
			total.append(a)
		else:
			a = (summa + min(m * counter, k)) / counter
			total.append(a)
print(max(total))


(n, k, m) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
s = sum(arr)
t = n
ma = 0
for i in range(n):
	ma = max((s + min(m, k * t)) / t, ma)
	if m == 0:
		break
	s -= arr[i]
	t -= 1
	m -= 1
print('%.20f' % ma)


(N, K, M) = map(int, input().split())
a = sorted(map(int, input().split()))
total = sum(a)
ans = (total + min(K * N, M)) / N
for n in a:
	if not M or N == 1:
		break
	M -= 1
	N -= 1
	total -= n
	ans = max(ans, (total + min(K * N, M)) / N)
print(ans)


(n, k, m) = map(int, input().split())
arr = list(map(int, input().split()))
a = []
a.append(0)
for i in arr:
	a.append(i)
a = sorted(a)
mm = (sum(arr) + min(m, n * k)) / n
ss = sum(arr)
for i in range(1, min(n - 1, m) + 1):
	ss -= a[i]
	baaki = ss + min(m - i, (n - i) * k)
	mm = max(mm, baaki / (n - i))
print('%.20f' % mm)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
s = sum(a)
if m <= k * n:
	ans = (s + m) / n
else:
	ans = (s + k * n) / n
for i in range(min(n - 1, m)):
	s = s - a[i]
	m -= 1
	if m <= k * (n - i - 1):
		t = (s + m) / (n - i - 1)
	else:
		t = (s + k * (n - i - 1)) / (n - i - 1)
	if t > ans:
		ans = t
print(ans)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
ans = sum(a)
r = 0
for i in range(n):
	if i <= m:
		r = max(r, (ans + min(k * (n - i), m - i)) / (n - i))
		ans -= a[i]
print(r)


(n, k, m) = map(int, input().split())
streng = sorted(list(map(int, input().split())))
alls = sum(streng)
M = 0
for i in range(len(streng)):
	cur = (alls + min(m, (n - i) * k)) / (len(streng) - i)
	if cur > M:
		M = cur
	alls -= streng[i]
	m -= 1
	if m < 0:
		break
print(M)


import sys
from math import *
from fractions import gcd
readints = lambda : map(int, input().strip('\n').split())
(n, k, m) = readints()
a = list(readints())
a.sort()
sm = sum(a)
best = sm / n
for i in range(n):
	if i > m:
		break
	ad = min(k * (n - i), m - i)
	cur = (sm + ad) / (n - i)
	best = max(cur, best)
	sm -= a[i]
print(best)


def __solve__():
	a = input().split()
	n = int(a[0])
	k = int(a[1])
	m = int(a[2])
	a = input().split()
	i = 0
	sum = 0
	for j in range(n):
		a[i] = int(a[i])
		sum += a[i]
		i += 1
	a.sort(key=None, reverse=False)
	res = sum / n
	cnt = min(n - 1, m)
	for j in range(cnt + 1):
		if j != 0:
			sum -= a[j - 1]
		add = min(k * (n - j), m - j)
		now = sum + add
		now /= n - j
		res = max(res, now)
	print(res)
__solve__()


(n, k, m) = list(map(int, input().split()))
ai = list(map(int, input().split()))
ai.sort()
n2 = n
num = sum(ai)
ans = 0.0
i = 0
while n2 > 0 and m > -1:
	num2 = (num + min(m, n2 * k)) / n2
	ans = max(ans, num2)
	num -= ai[i]
	i += 1
	n2 -= 1
	m -= 1
print(ans)


from collections import deque
import pdb
import heapq
from heapq import *
from pprint import pprint

def rI():
	return [int(i) for i in input().split()]
(n, k, m) = rI()
a = rI()
a.sort()
pref = [a[0]]
for i in range(1, len(a)):
	pref.append(pref[i - 1] + a[i])
mm = (pref[n - 1] + min(n * k, m)) / n
for i in range(len(a) - 1):
	if m == 0:
		break
	m -= 1
	zz = pref[n - 1] - pref[i]
	kk = n - i - 1
	zz += min(kk * k, m)
	mm = max(zz / kk, mm)
print(mm)


R = lambda : map(int, input().split())
(n, k, m) = R()
inp = R()
r = s = i = 0
for x in reversed(sorted(inp)):
	i += 1
	s += x
	if n - i <= m:
		r = max(r, (s + min(k * i, m - n + i)) / i)
print(r)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
s = sum(a)
ma = (s + min(m, n * k)) / n
for i in range(1, min(n - 1, m) + 1):
	s -= a[i - 1]
	temp = (s + min(m - i, (n - i) * k)) / (n - i)
	ma = max(ma, temp)
print(ma)


(n, k, m) = map(int, input().split())
A = sorted(list(map(int, input().split())))
sum_ = sum(A)
res = (sum(A) + min(m, n * k)) / n
for i in range(min(m, n - 1)):
	sum_ -= A[i]
	min_ = min(m - 1, (n - i - 1) * k)
	res = max(res, (sum_ + min_) / (n - i - 1))
	m -= 1
print(res)


def solve():
	(n, k, m) = map(int, input().split(' '))
	a = [0] + sorted(map(int, input().split(' ')))
	for _ in range(1, n + 1):
		a[_] = a[_] + a[_ - 1]
	ans = 0
	for _ in range(min(n, m + 1)):
		(n_, m_) = (n - _, m - _)
		ans = max((a[-1] - a[_] + min(m_, k * n_)) / n_, ans)
	print('%.9f' % ans)
solve()


(n, k, m) = input().split()
k = int(k)
m = int(m)
n = int(n)
niz = [int(n) for n in input().split()]
niz.sort()
suma = sum(niz)
curMax = (suma + min(m, n * k)) / n
for i in range(1, min(n - 1, m) + 1):
	suma -= niz[i - 1]
	tempMax = (suma + min(m - i, (n - i) * k)) / (n - i)
	if tempMax > curMax:
		curMax = tempMax
print(curMax)


import sys
import math

def main():
	fin = sys.stdin
	(n, k, m) = list(map(int, list(fin.readline().strip().split())))
	a = list(map(int, list(fin.readline().strip().split())))
	a = sorted(a, reverse=True)
	sm = sum(a)
	avg = sm / n
	maxavg = -math.inf
	dyn_sm = sm
	for n_rm in range(0, n):
		if n_rm > m:
			break
		dyn_sm -= a[n - n_rm] if n_rm > 0 else 0
		dyn_avg = (dyn_sm + ((n - n_rm) * k if (n - n_rm) * k <= m - n_rm else m - n_rm)) / (n - n_rm)
		maxavg = max(maxavg, dyn_avg)
	print(maxavg)

def __starting_point():
	main()
__starting_point()


read = lambda : map(int, input().split())
(n, k, m) = read()
a = list(read())
a.sort()
x = sum(a)
suma = [x]
for i in range(min(m, n - 1)):
	x -= a[i]
	suma.append(x)
mm = 0
for (cnt, i) in enumerate(suma):
	mm = max(mm, (i + min(m - cnt, k * (n - cnt))) / (n - cnt))
print('%.10f' % mm)


def cin():
	return map(int, input().split())
import collections
(n, k, m) = cin()
a = list(cin())
a.sort(reverse=True)
pref = [0]
for i in a:
	pref.append(pref[-1] + i)
ans = pref[-1] / n
for i in range(n, max(n - m - 1, 0), -1):
	ans = max(ans, (pref[i] + min(m - n + i, k * i)) / i)
print(ans)


(n, k, m) = map(int, input().split())
d = min(n * k, m)
q = list(map(int, input().split()))[:n]
a = [0]
a = a + q
a.sort()
ans = 0
x = sum(a)
for i in range(min(m, n - 1) + 1):
	x -= a[i]
	v = x + min(m - i, k * (n - i))
	ans = max(ans, v / (n - i))
print(ans)


from itertools import accumulate
(n, k, m) = [int(x) for x in input().split(' ')]
a = sorted([int(x) for x in input().split(' ')])
a_sum = sum(a)
pref_a = [0] + list(accumulate(a))

def score(rem):
	total = len(a) - rem
	return (a_sum - pref_a[rem] + min(total * k, m - rem)) / total
print(max(map(score, range(min(m + 1, len(a))))))


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
s = sum(a)
mv = 0
for i in range(min(n, m + 1)):
	la = m - i
	cs = s + min(la, k * (n - i))
	cv = cs / (n - i)
	if cv > mv:
		mv = cv
	s -= a[i]
print(mv)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
Sum = sum(a)
max_avg = Sum / n
a = sorted(a)
if m > n:
	if m - n >= k and max_avg < a[-1] + k:
		max_avg = a[-1] + k
	else:
		max_avg = a[-1] + m - n + 1
elif m == n:
	if max_avg < a[-1] + 1:
		max_avg = a[-1] + 1
else:
	if max_avg < (Sum + m) / n:
		max_avg = (Sum + m) / n
	for i in range(m):
		Sum -= a[i]
		max_avg = max(max_avg, (Sum + min(m - i - 1, k * (n - 1 - i))) / (n - i - 1))
print(max_avg)


vals = [int(r) for r in input().split()]
n = vals[0]
k = vals[1]
m = vals[2]
powers = sorted([int(r) for r in input().split()], reverse=True)
ans = 0
curr_sum = 0
for i in range(n):
	curr_sum += powers[i]
	if n - 1 - i > m:
		continue
	else:
		moves_left = m - (n - 1 - i)
		ppl_left = i + 1
		ans = max(ans, (curr_sum + min(moves_left, ppl_left * k)) / ppl_left)
print('{0:.20f}'.format(ans))


from bisect import bisect_left as bl
from bisect import bisect_right as br
import heapq
import math
from collections import *
from functools import reduce, cmp_to_key
import sys
input = sys.stdin.readline
M = mod = 10 ** 9 + 7

def factors(n):
	return sorted(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))

def inv_mod(n):
	return pow(n, mod - 2, mod)

def li():
	return [int(i) for i in input().rstrip('\n').split(' ')]

def st():
	return input().rstrip('\n')

def val():
	return int(input().rstrip('\n'))

def li2():
	return [i for i in input().rstrip('\n').split(' ')]

def li3():
	return [int(i) for i in input().rstrip('\n')]
(n, k, m) = li()
maxm = m
l = sorted(li())
help = [0 for i in range(n)]
j = 0
for i in range(n - 1, -1, -1):
	if not m:
		break
	curr = min(m, k)
	m -= curr
	l[i] += curr
	help[i] = curr
	if m == 0:
		j = i
currsum = sum(l)
currlen = n
tot = 0
for i in range(n - 1):
	if m or help[i]:
		if (currsum - l[i]) / (currlen - 1) >= currsum / currlen:
			currsum -= l[i]
			l[i] = 0
			currlen -= 1
			m += help[i] - 1
			tot += 1
	elif tot != maxm:
		if (currsum - l[i] - 1) / (currlen - 1) >= currsum / currlen:
			currsum -= l[i] + 1
			l[i] = 0
			currlen -= 1
			tot += 1
			help[j] -= 1
			l[j] -= 1
			if not help[j]:
				j += 1
print(sum(l) / currlen)


import sys
input = sys.stdin.readline

def main():
	(n, k, m) = map(int, input().split())
	a = list(map(int, input().split()))
	a.sort()
	if m == 1 and m != n:
		return max(sum(a[m:]) / (n - m), (sum(a) + 1) / n)
	if m > n:
		m -= n - 1
		return max(a) + min(k, m)
	if m == n:
		if n == 1:
			return max(a) + min(k, m)
		return max(a)
	q = set(a)
	l = len(q)
	cur = n
	cur_2 = m
	for i in range(len(a)):
		if l == 1 or cur_2 == 0:
			break
		else:
			q.discard(a[i])
			l -= 1
			cur -= 1
			cur_2 -= 1
	if l == 1 and cur_2 != 0:
		return q.pop() + cur_2 / cur
	return sum(a[m:]) / (n - m)
print('{0:8f}'.format(main()))


def main():
	(n, k, m) = map(int, input().split())
	a = list(map(int, input().split()))
	a.sort()
	sumo = sum(a)
	res = (sum(a) + min(m, k * n)) / n
	for i in range(min(n - 1, m)):
		sumo -= a[i]
		res = max(res, (sumo + min(m - i - 1, k * (n - i - 1))) / (n - i - 1))
	print('{:.10f}'.format(res))
main()


(n, k, m) = map(int, input().split())
a = sorted(list(map(int, input().split())))
s = sum(a)
smax = (s + min(m, n * k)) / n
for i in range(min(n - 1, m)):
	s -= a[i]
	stmp = s + min(m - (i + 1), (n - (i + 1)) * k)
	smax = max(smax, stmp / (n - (i + 1)))
print(smax)


from sys import stdin, stdout
from math import *
from heapq import *
from collections import *

def main():
	(n, k, m) = [int(x) for x in stdin.readline().split()]
	a = [int(x) for x in stdin.readline().split()]
	a.sort(reverse=True)
	s = [0] * (n + 2)
	a = [0] + a
	for i in range(1, n + 1):
		s[i] = s[i - 1] + a[i]
	res = s[n] / n
	i = n
	while i >= 1:
		if m < 0:
			break
		res = max(res, (s[i] + min(k * i, m)) / i)
		m = m - 1
		i = i - 1
	stdout.write('%.9f' % res)
	return 0

def __starting_point():
	main()
__starting_point()


def main():
	(n, k, m) = [int(v) for v in input().split()]
	vals = [int(v) for v in input().split()]
	vals.sort()
	data = [vals[0]]
	for i in range(1, n):
		data.append(data[i - 1] + vals[i])
	max_v = 0
	total = data[-1]
	for i in range(0, min(m + 1, n)):
		s = total - (data[i - 1] if i > 0 else 0)
		add_v = min(k * (n - i), m - i)
		max_v = max(max_v, (s + add_v) / (n - i))
	print(max_v)
main()


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort(reverse=True)
if n == 1:
	print(a[0] + min(m, k))
	exit()
pr = [0 for i in range(n + 1)]
pr[0] = 0
mx = 0
eps = 1e-07
for i in range(1, n + 1):
	pr[i] = pr[i - 1] + a[i - 1]
for c in range(max(n - m, 1), n + 1):
	l = n - c
	if (pr[c] + min(c * k, m - n + c)) / c - mx > eps:
		mx = (pr[c] + min(c * k, m - l)) / c
print(mx)


(n, k, m) = map(int, input().split())
a = [int(i) for i in input().split()]
a = sorted(a)
s = sum(a)
ans = 0
for i in range(min(n, m + 1)):
	s += min(k * (n - i), m - i)
	ans = max(s / (len(a) - i), ans)
	s -= min(k * (n - i), m - i)
	s -= a[i]
print(ans)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
mav = 0
i = 0
j = 0
x = sum(a)
lenth = n
while i < n and j <= m:
	avg = (x + min((k * lenth, max(0, m - i)))) / lenth
	if avg > mav:
		mav = avg
	x -= a[i]
	lenth -= 1
	j += 1
	i += 1
print(mav)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
for i in range(n - 2, -1, -1):
	a[i] = a[i] + a[i + 1]
max_num = (a[0] + min(k * n, m)) / n
for i in range(1, n):
	if i > m:
		break
	res = (a[i] + min((n - i) * k, m - i)) / (n - i)
	max_num = max(max_num, res)
print(max_num)


(n, k, m) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
suma = sum(l)
maximo = 0
for i in range(min(m + 1, len(l))):
	t = (suma + min(m - i, k * (n - i))) / (n - i)
	maximo = max(maximo, t)
	suma -= l[i]
print(maximo)


from statistics import mean

def main():
	nkm = [int(i) for i in input().split()]
	a = [int(i) for i in input().split()]
	(n, k, m) = nkm
	a = sorted(a)
	sm = sum(a)
	max_avg = (sm + min(m, k * n)) / n
	limit = min(n - 1, m)
	for i in range(limit):
		sm -= a[i]
		avg = (sm + min(m - (i + 1), k * (n - (i + 1)))) / (n - (i + 1))
		max_avg = max(max_avg, avg)
	print(max_avg)
main()


import sys
import math
(n, k, m) = map(int, sys.stdin.readline().split())
arr = list(map(int, sys.stdin.readline().split()))
s = sum(arr)
avg = (s + min(m, k * n)) / n
cnt = n
ops = 0
remove = 0
cur = 0
arr.sort()
for i in range(n - 1):
	remove += arr[i]
	cnt -= 1
	ops += 1
	cur += 1
	if m >= ops:
		ag = s - remove + min(m - ops, k * cnt)
		ag /= cnt
		avg = max(avg, ag)
print(avg)


(n, k, m) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
sum = 0
for i in l:
	sum += i
if n * k < m:
	(avg, i) = ((sum + n * k) / n, 0)
else:
	(avg, i) = ((sum + m) / n, 0)
while m and n != 1:
	m = m - 1
	n = n - 1
	if n * k < m:
		temp = (sum - l[i] + n * k) / n
		sum = sum - l[i]
	else:
		temp = (sum - l[i] + m) / n
		sum = sum - l[i]
	i = i + 1
	if temp > avg:
		avg = temp
print(avg)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
total = sum(a)
avgs = []
for i in range(0, n):
	remain = max(m - i, 0)
	ln = n - i
	each = remain // ln
	sm = 0
	if each >= k:
		sm = total / ln + k
	else:
		sm = (total + remain) / ln
	avgs.append(sm)
	total -= a[i]
	if remain == 0:
		break
print(max(avgs))


(n, k, m) = input().split()
n = int(n)
k = int(k)
m = int(m)
a = [int(x) for x in input().split()]
a.sort()
avg = []
s = sum(a)
for i in range(0, n):
	if i > 0:
		s = s - a[i - 1]
	if i > m:
		break
	if (m - i) / k <= n - i:
		avg.append((s + m - i) / (n - i))
	else:
		avg.append((s + (n - i) * k) / (n - i))
print(max(avg))


import time
from math import *

def main():
	(n, k, m) = map(int, input().split())
	power = sorted(list(map(int, input().split())))
	total = sum(power)
	maxpower = (total + min(m, n * k)) / n
	for i in range(min(n - 1, m)):
		total -= power[i]
		tmp = total + min(m - i - 1, (n - i - 1) * k)
		maxpower = max(maxpower, tmp / (n - i - 1))
	print(maxpower)
main()


def solve(a, n, k, m):
	a.sort(reverse=True)
	sm = sum(a)
	avg = float((sm + min(len(a) * k, m)) / len(a))
	while len(a) > 1 and m > 0:
		m -= 1
		sm -= a.pop()
		avg = max(avg, (sm + min(len(a) * k, m)) / len(a))
	return avg
(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
print(solve(a, n, k, m))


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
add = list((0 for _ in range(n)))
a.sort()
sm = int(sum((_ for _ in a)))
res = 0
for i in range(min(m, n - 1)):
	res = max(res, (sm + min((n - i) * k, m - i)) / (n - i))
	if i < m:
		res = max(res, (sm - a[i]) / (n - (i + 1)))
	sm -= a[i]
if n <= m:
	res = max(res, a[n - 1] + min(k, m - n + 1))
print(res)


(n, k, m) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort(reverse=True)
for i in range(1, len(a)):
	a[i] += a[i - 1]
for i in range(n):
	if n - 1 - i <= m:
		a[i] = float(a[i] + min(m - (n - 1 - i), k * (i + 1))) / (i + 1)
print(max(a[max(n - 1 - m, 0):]))


import sys
(n, k, m) = [int(tmp) for tmp in sys.stdin.readline().split()]
a = [int(tmp) for tmp in sys.stdin.readline().split()]
a.sort(reverse=True)
sa = sum(a)
sar = sa
ld = n - min([n, m + 1])
rd = n
while rd - ld != 1:
	td = (ld + 1 + rd) // 2
	avsidthau = (sar - sum(a[td:rd]) + min([m - (n - td), td * k])) / td
	avsiuth = (sar + min([rd * k, m - (n - rd)])) / rd
	if avsidthau > avsiuth:
		sar -= sum(a[td:rd])
		rd = td
	else:
		ld = td
sar += min([m - (n - rd), rd * k])
avs = sar / rd
print(avs)


def check(sumPower, heroesAmount, operations, k):
	return (sumPower + min(heroesAmount * k, operations)) / heroesAmount

def maxPower():
	(n, k, m) = map(int, input().split())
	if n == 0:
		print(0.0)
		return
	array = sorted(list(map(int, input().split())))
	sumPower = 0
	heroesAmount = n
	for i in array:
		sumPower += i
	maxMidPower = check(sumPower, heroesAmount, m, k)
	for i in range(0, len(array) - 1):
		sumPower -= array[i]
		heroesAmount -= 1
		m -= 1
		maxMidPower = max(maxMidPower, check(sumPower, heroesAmount, m, k))
		if m == 0:
			break
	return maxMidPower
print(maxPower())


input1 = input().split(' ')
input2 = input().split(' ')
member = int(input1[0])
limit = int(input1[1])
operation = int(input1[2])
power = []
for i in range(member):
	power.append(int(input2[i]))
power.sort()
Sum = sum(power)
maximum = (Sum + (limit * member if limit * member < operation else operation)) / member
for i in range(operation):
	Sum -= power[i]
	member -= 1
	if member == 0:
		break
	temp = (Sum + (limit * member if limit * member < operation - i - 1 else operation - i - 1)) / member
	if temp > maximum:
		maximum = temp
print(maximum)


(n, k, m) = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
sum_A = sum(A)
avg = sum_A / n
i = 0
potential = lambda n, k, m: min(k * n, m) / n
avg_subtracted = lambda s, n, a: (s - a) / (n - 1)
while n > 1 and m > 0 and (i < len(A)) and (avg_subtracted(sum_A, n, A[i]) + potential(n - 1, k, m - 1) >= avg + potential(n, k, m)):
	sum_A -= A[i]
	n -= 1
	avg = sum_A / n
	i += 1
	m -= 1
if i < len(A):
	avg += potential(n, k, m)
print(avg)


(n, k, m) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a.sort(reverse=True)
l = min(a)
s = sum(a)
max_s = 0
while m > 0 and a:
	max_s = max((s + min(m, k * len(a))) / len(a), max_s)
	s -= a.pop()
	m -= 1
if a:
	max_s = max((s + min(m, k * len(a))) / len(a), max_s)
print(max_s)


(n, k, m) = map(int, input().split())
v = list(map(int, input().split()))
r = s = i = 0
for x in reversed(sorted(v)):
	i += 1
	s += x
	if n - i <= m:
		r = max(r, (s + min(k * i, m - n + i)) / i)
print(r)


(n, k, m) = map(int, input().split())
a = list(sorted(map(int, input().split()), reverse=True))
best_avg = 0
s = sum(a)
for i in range(len(a)):
	if i > m:
		break
	if i > 0:
		s -= a[-i]
	best_avg = max(best_avg, (s + min((len(a) - i) * k, m - i)) / (len(a) - i))
print(best_avg)


def get():
	return list(map(int, input().split()))
(n, k, m) = get()
a = get()
a.sort()
c = (n + 1) * [0]
c[0] = 0
for i in range(1, n + 1):
	c[i] = c[i - 1] + a[i - 1]
f = (c[n] - c[0] + min(m, n * k)) / n
for i in range(1, n):
	if m - i >= 0:
		f = max((c[n] - c[i] + min(m - i, (n - i) * k)) / (n - i), f)
print(f)


import sys

def max_average(H, N, K, M):

	def prefix_sum():
		presum = [0]
		s = 0
		for e in H:
			s = s + e
			presum.append(s)
		return presum
	SH = prefix_sum()
	avgs = [(SH[N] - SH[i] + min(M - i, K * (N - i))) / (N - i) for i in range(min(M + 1, N))]
	return max(avgs)

def main():
	(N, K, M) = tuple((int(x) for x in input().split(' ')))
	H = sorted(tuple((int(h) for h in input().split(' '))))
	print(max_average(H, N, K, M))
main()


(n, k, m) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
me = arr[n - 1]
ind = 0
sarr = [0 for i in range(n + 1)]
for i in range(n - 1, -1, -1):
	sarr[i] = sarr[i + 1] + arr[i]
ans = (sarr[0] + min(m, n * k)) / n
for i in range(min(m, n - 1)):
	temp = sarr[i + 1] + min(m - 1 - i, (n - 1 - i) * k)
	temp = temp / (n - 1 - i)
	ans = max(ans, temp)
print(ans)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
sumi = sum(a)
ans = sumi / n
ct = 0
add = min(k * n, m - ct)
ans = max(ans, (sumi + add) / n)
for i in a:
	sumi -= i
	ct += 1
	n -= 1
	if ct > m or n == 0:
		break
	add = min(k * n, m - ct)
	ans = max(ans, (sumi + add) / n)
print(ans)


(n, k, m) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
sm = 0
ans = 0
for i in range(len(arr) - 1, -1, -1):
	sm += arr[i]
	if i <= m:
		sm += min(k * (n - i), m - i)
		ans = max(ans, sm / (n - i))
		sm -= min(k * (n - i), m - i)
print(ans)


import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians
if sys.version_info.minor >= 5:
	from math import gcd
else:
	from fractions import gcd
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def ceil(a, b=1):
	return int(-(-a // b))

def round(x):
	return int((x * 2 + 1) // 2)

def fermat(x, y, MOD):
	return x * pow(y, MOD - 2, MOD) % MOD

def lcm(x, y):
	return x * y // gcd(x, y)

def lcm_list(nums):
	return reduce(lcm, nums, 1)

def gcd_list(nums):
	return reduce(gcd, nums, nums[0])

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST():
	return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
(N, K, M) = MAP()
aN = LIST()
aN.sort()
mx = max(aN)
idx = bisect_left(aN, mx)
if idx <= M:
	M2 = M - idx
	aN2 = aN[idx:]
	for i in range(len(aN2)):
		if M2 >= K:
			aN2[i] += K
			M2 -= K
		else:
			aN2[i] += M2
			M2 = 0
			break
	M -= len(aN) - 1
	aN = aN[-1:]
	aN[0] += min(M, K)
	ans = max(sum(aN) / len(aN), sum(aN2) / len(aN2))
else:
	aN2 = aN[M:]
	for i in range(len(aN)):
		if M >= K:
			aN[i] += K
			M -= K
		else:
			aN[i] += M
			M = 0
			break
	ans = max(sum(aN) / len(aN), sum(aN2) / len(aN2))
print(ans)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
b = []
s = sum(a)
for i in range(n):
	if i > 0:
		s -= a[i - 1]
	if m < i:
		break
	if (n - i) * k >= m - i:
		b.append((s + m - i) / (n - i))
	else:
		b.append((s + (n - i) * k) / (n - i))
print(max(b))


import sys
input = sys.stdin.readline
for _ in range(1):
	(n, k, m) = map(int, input().split())
	l = list(map(int, input().split()))
	l.sort()
	som = sum(l)
	rem = m // k
	rem_dash = m % k
	ans = (som + min(n * k, rem * k + rem_dash)) / n
	cnt = n
	for i in range(min(n - 1, m)):
		m -= 1
		som -= l[i]
		cnt -= 1
		rem = m // k
		rem_dash = m % k
		ans = max((som + min(cnt * k, rem * k + rem_dash)) / cnt, ans)
	print(ans)


(n, k, m) = map(int, input().split())
array = list(map(int, input().split()))
array.sort()
array = [0] + array
sr = sum(array) / n
sr_max = sr
sr_max += min(m / n, k)
l = n
for i in range(1, min(n, m + 1)):
	sr = (sr * l - array[i]) / (l - 1)
	sr_max = max(sr + min((m - i) / (l - 1), k), sr_max)
	l -= 1
print(sr_max)


import sys
input = sys.stdin.readline
(n, k, m) = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
SUM = sum(A)
ANS = 0
for i in range(min(n, m + 1)):
	MPOWER = SUM + min(m - i, (n - i) * k)
	ANS = max(ANS, MPOWER / (n - i))
	SUM -= A[i]
print(ANS)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
sm = sum(a)
ans = (sm + min(n * k, m)) / n
i = 0
while True:
	if i == n - 1 or i == m:
		break
	sm -= a[i]
	tans = (sm + min(m - i - 1, (n - i - 1) * k)) / (n - i - 1)
	if tans < ans:
		break
	ans = tans
	i += 1
print(ans)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
r = min(m, n - 1)
s = sum(a)
ans = (s + min(m, k * n)) / n
for i in range(0, r):
	s -= a[i]
	t = (s + min(m - i - 1, k * (n - i - 1))) / (n - i - 1)
	ans = max(t, ans)
print(ans)


import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
(N, K, M) = map(int, input().split())
L = list(map(int, input().split()))
S = sum(L)
L = sorted(L)
ans = -float('inf')
ans = (S + min(M, K * N)) / N
for i in range(0, min(M, N - 1)):
	rM = M - i - 1
	rN = N - i - 1
	S -= L[i]
	tmpA = (S + min(rM, rN * K)) / rN
	ans = max(tmpA, ans)
print(ans)


def operation(a, last_index, sum_before_last_index, operation_index):
	if last_index == 0:
		a[0] += 1
		return (last_index, sum_before_last_index)
	if sum_before_last_index >= last_index * (a[last_index] + 1):
		return (last_index - 1, sum_before_last_index - a[last_index - 1])
	else:
		a[operation_index] += 1
		return (last_index, sum_before_last_index)

def foo(n, k, m, a):
	if n == 1:
		return a[0] + min(k, m)
	last_index = n - 1
	sum_before_last_index = sum(a[:last_index])
	i = 0
	j = 0
	operation_index = 0
	while operation_index <= last_index and i < m:
		prev = last_index
		(last_index, sum_before_last_index) = operation(a, last_index, sum_before_last_index, operation_index)
		i += 1
		if prev == last_index:
			j += 1
			if j % k == 0:
				operation_index += 1
	return sum(a[:last_index + 1]) / (last_index + 1)

def foo2(n, k, m, a):
	sum_del_i = sum(a)
	mx = (sum_del_i + min(m, n * k)) / n
	for i in range(1, min(n, m + 1)):
		sum_del_i = sum_del_i - a[i - 1]
		mx = max(mx, (sum_del_i + min(m - i, (n - i) * k)) / (n - i))
	return mx
(n, k, m) = [int(x) for x in input().split()]
a = [int(i) for i in input().split()]
a.sort()
print(foo2(n, k, m, a))


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
sm = sum(a)
mx = (sm + min(m, n * k)) / n
for i in range(min(n - 1, m)):
	sm -= a[i]
	q = sm + min(m - i - 1, (n - i - 1) * k)
	mx = max(mx, q / (n - i - 1))
print(format(mx, '.20f'))


import sys
(n, k, m) = [int(tmp) for tmp in sys.stdin.readline().split()]
a = [int(tmp) for tmp in sys.stdin.readline().split()]
a.sort(reverse=True)
sa = sum(a)
mr = m
nr = n
sar = sa
while nr >= 2 and mr != 0:
	avsidau = (sar - a[nr - 1] + min([mr - 1, (nr - 1) * k])) / (nr - 1)
	avsiu = (sar + min([nr * k, mr])) / nr
	if avsidau > avsiu:
		mr -= 1
		nr -= 1
		sar -= a[nr]
	else:
		break
sar += min([nr * k, mr])
avs = sar / nr
print(avs)


(n, k, m) = map(int, input().split())
a = sorted([int(x) for x in input().split()])
prefix_sum = [sum(a)]
for i in range(n):
	prefix_sum.append(prefix_sum[-1] - a[i])
ans = (sum(a) + min(m, n * k)) / n
for i in range(1, min(m, n - 1) + 1):
	a = (prefix_sum[i] + min(m - i, k * (n - i))) / (n - i)
	ans = max(ans, a)
print(ans)


(n, k, m) = map(int, input().split())
a = sorted(list(map(int, input().split())), reverse=True)
p = [0] * (n + 1)
for i in range(1, n + 1):
	p[i] = p[i - 1] + a[i - 1]
ans = 0
for i in range(0, min(n - 1, m) + 1):
	ans = max(ans, (p[n - i] + min(m - i, (n - i) * k)) / (n - i))
print(ans)


from math import floor
(n, k, m) = map(int, input().split())
a = [int(x) for x in input().split()]
if n == 1:
	print(a[0] + min(k, m))
else:
	a = sorted(a, reverse=True)
	if n >= 2:
		breaking = True
		firstly = True
		N = n
		sum_a = sum(a[0:N])
		if m >= N * k:
			score = (sum_a + N * k) / N
		else:
			M = m // k
			r = m % k
			score = (sum_a + M * k + r) / N
		max_score = score
		while breaking:
			sum_a = sum_a - a[N - 1]
			N = N - 1
			m = m - 1
			if N == 1:
				new_score = a[0] + min(k, m)
			elif m >= N * k:
				new_score = (sum_a + N * k) / N
			else:
				M = m // k
				r = m % k
				new_score = (sum_a + M * k + r) / N
			if new_score > max_score:
				max_score = new_score
			if N == 1 or m == 0:
				breaking = False
			score = new_score
		print(max_score)


(n, k, m) = map(int, input().split())
a = sorted(list(map(int, input().split())))
av = (sum(a) + min(n * k, m)) / n
r = 0
l = sum(a)
for i in range(min(n - 1, m)):
	r += a[i]
	av = max(av, (l - r + min(m - i - 1, (n - i - 1) * k)) / (n - i - 1))
print(av)


from math import ceil, sqrt, gcd, log, floor
from collections import deque

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().strip().split(' '))

def li():
	return list(mi())

def msi():
	return map(str, input().strip().split(' '))

def lsi():
	return list(msi())
(n, k, m) = mi()
a = li()
s = sum(a)
a.sort()
s2 = s + min(k * n, m)
ans = s2 / n
s1 = 0
x = n
for i in range(n - 1):
	m -= 1
	s1 += a[i]
	s3 = s - s1 + min(k * (n - i - 1), m)
	s3 /= n - i - 1
	if ans < s3:
		ans = s3
	if m == 0:
		break
print('%0.8f' % ans)


import sys
import math

def read_int():
	return int(input().strip())

def read_int_list():
	return list(map(int, input().strip().split()))

def read_string():
	return input().strip()

def read_string_list(delim=' '):
	return input().strip().split(delim)
(n, k, m) = read_int_list()
arr = read_int_list()
arr.sort(reverse=True)
total = sum(arr)
reverse_total = 0
max_avg = total / n
max_avg = max(max_avg, (total + min(k * n, m)) / n)
for i in range(1, min(n, m + 1)):
	deletion = i
	addition = min(m - i, k * (n - i))
	reverse_total += arr[n - i]
	new_avg = (total - reverse_total + addition) / (n - i)
	max_avg = max(max_avg, new_avg)
print(max_avg)


(n, k, m) = map(int, input().split())
lst = [*map(int, input().split())]
summa = sum(lst)
res = 0
lst.sort()
for (i, x) in enumerate(lst):
	if m < 0:
		break
	new = (summa + min(n * k, m)) / n
	summa -= x
	n -= 1
	m -= 1
	if new < res:
		break
	res = new
print(res)


(N, K, M) = list(map(int, input().split()))
A = list(map(int, input().split()))
A = sorted(A)
maxavg = sum(A) / len(A)
ss = sum(A)
for i in range(min(N, M + 1)):
	if i > 0:
		ss = ss - A[i - 1]
	maxadvg = min(K * (N - i), M - i)
	maxavg = max(maxavg, (ss + maxadvg) / (N - i))
print(maxavg)


def main():
	(n, k, m) = map(int, input().split())
	a = list(map(int, input().split()))
	a.sort()
	total_sum = sum(a)
	ret = (total_sum + min(m, n * k)) / n
	for i in range(min(n - 1, m)):
		total_sum -= a[i]
		temp = total_sum + min(m - i - 1, (n - i - 1) * k)
		ret = max(ret, temp / (n - i - 1))
	print(ret)
main()


(n, k, m) = (int(i) for i in input().strip().split())
arr = [int(x) for x in input().split()]
arr = sorted(arr)
sum = sum(arr)
for i in range(n):
	mid1 = 0 if n - i - 1 == 0 else (sum - arr[i] + min(k * (n - i - 1), m - 1)) / (n - i - 1)
	mid2 = (sum + min(k * (n - i), m)) / (n - i)
	if mid1 > mid2 and m != 0:
		m -= 1
		sum -= arr[i]
	else:
		print(mid2)
		break


(n, k, m) = map(int, input().split())
from sys import stdin
l = list(map(int, stdin.readline().split()))
l.sort()
l1 = []
sm = 0
for i in l:
	sm += i
	l1.append(sm)
l2 = []
for i in range(0, min(n - 1, m)):
	l2.append((l1[-1] - l1[i] + min(k * (n - i - 1), m - i - 1)) / (n - i - 1))
l2.append((sum(l) + min(n * k, m)) / n)
print(max(l2))


(nheroes, ninc, nops) = map(int, input().split())
pows = [p for p in map(float, input().split())]
total_pow = sum(pows)
max_avg = float('-inf')
pows.sort()
for i in range(min(nheroes, nops)):
	max_inc = min(nheroes * ninc, nops - i)
	new_max = (total_pow + max_inc) / nheroes
	max_avg = max(max_avg, new_max)
	total_pow -= pows[i]
	nheroes -= 1
if nheroes >= 1:
	print(max(max_avg, total_pow / nheroes))
else:
	print(max_avg)


(n, k, m) = map(int, input().split())
li = list(map(int, input().split()))
li.sort(reverse=True)
s = sum(li)
s1 = 0
i = n - 1
ma = 0
j = 0
while i >= 0 and j <= m:
	ma = max(ma, (s + min(m - j, k * (n - j))) / (n - j))
	s -= li[i]
	j += 1
	i -= 1
print(ma)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
ans = sum(a) / n
cm = [a[0]]
for i in range(1, n):
	cm.append(cm[-1] + a[i])
cm.append(0)
for d in range(min(n, m + 1)):
	nb = min((m - d) // k, n - d)
	r = (m - d) % k if nb < n - d else 0
	ans = max(ans, (cm[-2] - cm[d - 1] + nb * k + r) / (n - d))
print(ans)


def superhero_problem():
	(n, k, m) = input().split(' ')
	tmp = input().split(' ')
	(n, k, m) = (int(n), int(k), int(m))
	sum = 0
	for (i, _) in enumerate(tmp):
		tmp[i] = int(tmp[i])
		sum += tmp[i]
	tmp = sorted(tmp)
	a = [0]
	a.extend(tmp)
	answer = (sum + min(n * k, m)) / n
	for i in range(1, n):
		op = m - i
		sum -= a[i]
		if op < 0:
			break
		answer = max(answer, (sum + min((n - i) * k, op)) / (n - i))
	print(answer)
	return
superhero_problem()


import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
sm = sum(a)
avg = 0
for i in range(min(m + 1, n)):
	avg = max(avg, (sm + min(k * (n - i), m - i)) / (n - i))
	sm -= a[i]
print(avg)


R = lambda : map(int, input().split())
(n, k, m) = R()
L = sorted(R(), reverse=True)
s = sum(L)
s1 = 0
i = n - 1
ma = 0
j = 0
while i >= 0 and j <= m:
	ma = max(ma, (s + min(m - j, k * (n - j))) / (n - j))
	s -= L[i]
	j += 1
	i -= 1
print(ma)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
s = sum(a)
a.sort()
i = 0
max_s = (s + min(m, n * k)) / n
while m > 0 and i < n - 1:
	s -= a[i]
	m -= 1
	i += 1
	max_s = max(max_s, (s + min(m, (n - i) * k)) / (n - i))
print(max_s)


def read_nums():
	return [int(x) for x in input().split()]

def count_deletes(nums, m, k):
	pass

def main():
	(n, k, m) = read_nums()
	nums = sorted(read_nums())
	cum_nums = [nums[0]]
	for i in range(1, len(nums)):
		cum_nums.append(nums[i] + cum_nums[i - 1])
	total_sum = cum_nums[-1]
	results = []
	for del_index in range(min(m + 1, n)):
		right_sum = total_sum - cum_nums[del_index - 1] if del_index > 0 else total_sum
		elem_left = n - del_index
		to_add = min(m - del_index, k * elem_left)
		cur_res = (right_sum + to_add) / elem_left
		results.append(cur_res)
	print(max(results))
main()


from bisect import bisect_right as br
from bisect import bisect_left as bl
from collections import defaultdict
from itertools import combinations
import functools
import sys
import math
MAX = sys.maxsize
MAXN = 10 ** 6 + 10
MOD = 10 ** 9 + 7

def isprime(n):
	n = abs(int(n))
	if n < 2:
		return False
	if n == 2:
		return True
	if not n & 1:
		return False
	for x in range(3, int(n ** 0.5) + 1, 2):
		if n % x == 0:
			return False
	return True

def mhd(a, b, x, y):
	return abs(a - x) + abs(b - y)

def numIN():
	return map(int, sys.stdin.readline().strip().split())

def charIN():
	return sys.stdin.readline().strip().split()

def chk(x):
	print('Hello', x)

def ncr(n, k):
	res = 1
	c = [0] * (k + 1)
	c[0] = 1
	for i in range(1, n + 1):
		for j in range(min(i, k), 0, -1):
			c[j] = (c[j] + c[j - 1]) % MOD
	return c[k]
(n, k, m) = numIN()
l = [0] + list(numIN())
l.sort()
s = sum(l)
mx = -1
for i in range(min(n, m + 1)):
	s -= l[i]
	x = s + min(m - i, k * (n - i))
	mx = max(mx, x / (n - i))
print(mx)


from sys import stdin, stdout
import cProfile, math
from collections import Counter
from bisect import bisect_left, bisect, bisect_right
import itertools
from copy import deepcopy
from fractions import Fraction
import sys, threading
import operator as op
from functools import reduce
sys.setrecursionlimit(10 ** 6)
threading.stack_size(2 ** 27)
fac_warmup = False
printHeap = str()
memory_constrained = False
P = 10 ** 9 + 7
import sys

class Operation:

	def __init__(self, name, function, function_on_equal, neutral_value=0):
		self.name = name
		self.f = function
		self.f_on_equal = function_on_equal

def add_multiple(x, count):
	return x * count

def min_multiple(x, count):
	return x

def max_multiple(x, count):
	return x
sum_operation = Operation('sum', sum, add_multiple, 0)
min_operation = Operation('min', min, min_multiple, 1000000000.0)
max_operation = Operation('max', max, max_multiple, -1000000000.0)

class SegmentTree:

	def __init__(self, array, operations=[sum_operation, min_operation, max_operation]):
		self.array = array
		if type(operations) != list:
			raise TypeError('operations must be a list')
		self.operations = {}
		for op in operations:
			self.operations[op.name] = op
		self.root = SegmentTreeNode(0, len(array) - 1, self)

	def query(self, start, end, operation_name):
		if self.operations.get(operation_name) == None:
			raise Exception('This operation is not available')
		return self.root._query(start, end, self.operations[operation_name])

	def summary(self):
		return self.root.values

	def update(self, position, value):
		self.root._update(position, value)

	def update_range(self, start, end, value):
		self.root._update_range(start, end, value)

	def __repr__(self):
		return self.root.__repr__()

class SegmentTreeNode:

	def __init__(self, start, end, segment_tree):
		self.range = (start, end)
		self.parent_tree = segment_tree
		self.range_value = None
		self.values = {}
		self.left = None
		self.right = None
		if start == end:
			self._sync()
			return
		self.left = SegmentTreeNode(start, start + (end - start) // 2, segment_tree)
		self.right = SegmentTreeNode(start + (end - start) // 2 + 1, end, segment_tree)
		self._sync()

	def _query(self, start, end, operation):
		if end < self.range[0] or start > self.range[1]:
			return None
		if start <= self.range[0] and self.range[1] <= end:
			return self.values[operation.name]
		self._push()
		left_res = self.left._query(start, end, operation) if self.left else None
		right_res = self.right._query(start, end, operation) if self.right else None
		if left_res is None:
			return right_res
		if right_res is None:
			return left_res
		return operation.f([left_res, right_res])

	def _update(self, position, value):
		if position < self.range[0] or position > self.range[1]:
			return
		if position == self.range[0] and self.range[1] == position:
			self.parent_tree.array[position] = value
			self._sync()
			return
		self._push()
		self.left._update(position, value)
		self.right._update(position, value)
		self._sync()

	def _update_range(self, start, end, value):
		if end < self.range[0] or start > self.range[1]:
			return
		if start <= self.range[0] and self.range[1] <= end:
			self.range_value = value
			self._sync()
			return
		self._push()
		self.left._update_range(start, end, value)
		self.right._update_range(start, end, value)
		self._sync()

	def _sync(self):
		if self.range[0] == self.range[1]:
			for op in self.parent_tree.operations.values():
				current_value = self.parent_tree.array[self.range[0]]
				if self.range_value is not None:
					current_value = self.range_value
				self.values[op.name] = op.f([current_value])
		else:
			for op in self.parent_tree.operations.values():
				result = op.f([self.left.values[op.name], self.right.values[op.name]])
				if self.range_value is not None:
					bound_length = self.range[1] - self.range[0] + 1
					result = op.f_on_equal(self.range_value, bound_length)
				self.values[op.name] = result

	def _push(self):
		if self.range_value is None:
			return
		if self.left:
			self.left.range_value = self.range_value
			self.right.range_value = self.range_value
			self.left._sync()
			self.right._sync()
			self.range_value = None

	def __repr__(self):
		ans = '({}, {}): {}\n'.format(self.range[0], self.range[1], self.values)
		if self.left:
			ans += self.left.__repr__()
		if self.right:
			ans += self.right.__repr__()
		return ans

def display(string_to_print):
	stdout.write(str(string_to_print) + '\n')

def primeFactors(n):
	factors = dict()
	for i in range(2, math.ceil(math.sqrt(n)) + 1):
		while n % i == 0:
			if i in factors:
				factors[i] += 1
			else:
				factors[i] = 1
			n = n // i
	if n > 2:
		factors[n] = 1
	return factors

def isprime(n):
	if n < 4:
		return True
	if n % 2 == 0:
		return False
	if n % 3 == 0:
		return False
	i = 5
	w = 2
	while i * i <= n:
		if n % i == 0:
			return False
		i += w
		w = 6 - w
	return True
factorial_modP = []

def warm_up_fac(MOD):
	nonlocal factorial_modP, fac_warmup
	if fac_warmup:
		return
	factorial_modP = [1 for _ in range(fac_warmup_size + 1)]
	for i in range(2, fac_warmup_size):
		factorial_modP[i] = factorial_modP[i - 1] * i % MOD
	fac_warmup = True

def InverseEuler(n, MOD):
	return pow(n, MOD - 2, MOD)

def nCr(n, r, MOD):
	nonlocal fac_warmup, factorial_modP
	if not fac_warmup:
		warm_up_fac(MOD)
		fac_warmup = True
	return factorial_modP[n] * (pow(factorial_modP[r], MOD - 2, MOD) * pow(factorial_modP[n - r], MOD - 2, MOD) % MOD) % MOD

def test_print(*args):
	if testingMode:
		print(args)

def display_list(list1, sep=' '):
	stdout.write(sep.join(map(str, list1)) + '\n')

def get_int():
	return int(stdin.readline().strip())

def get_tuple():
	return map(int, stdin.readline().split())

def get_list():
	return list(map(int, stdin.readline().split()))
import heapq, itertools
pq = []
entry_finder = {}
REMOVED = '<removed-task>'

def add_task(task, priority=0):
	if task in entry_finder:
		remove_task(task)
	count = next(counter)
	entry = [priority, count, task]
	entry_finder[task] = entry
	heapq.heappush(pq, entry)

def remove_task(task):
	entry = entry_finder.pop(task)
	entry[-1] = REMOVED

def pop_task():
	while pq:
		(priority, count, task) = heapq.heappop(pq)
		if task is not REMOVED:
			del entry_finder[task]
			return task
	raise KeyError('pop from an empty priority queue')
memory = dict()

def clear_cache():
	nonlocal memory
	memory = dict()

def cached_fn(fn, *args):
	nonlocal memory
	if args in memory:
		return memory[args]
	else:
		result = fn(*args)
		memory[args] = result
		return result
TestCases = False
testingMode = False
fac_warmup_size = 10 ** 5 + 100
optimiseForReccursion = True

def isVowel(c):
	return True if c == 'a' or c == 'e' or c == 'i' or (c == 'o') or (c == 'u') else False

def main():
	(n, k, m) = get_tuple()
	li = get_list()
	li.sort(reverse=True)
	sm = [0 for _ in range(n)]
	sum1 = 0
	for (i, ele) in enumerate(li):
		sum1 += ele
		sm[n - i - 1] = sum1 / (i + 1)
	li.reverse()
	res = 0
	i = 0
	while m >= 0 and i < n:
		res = max(res, sm[i] + min(m / (n - i), k))
		i += 1
		m -= 1
	print(res)
if TestCases:
	for _ in range(get_int()):
		cProfile.run('main()') if testingMode else main()
else:
	(cProfile.run('main()') if testingMode else main()) if not optimiseForReccursion else threading.Thread(target=main).start()


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort(reverse=True)
s = sum(a)
ans = 0
while n > 0 and m > -1:
	s2 = (s + min(m, n * k)) / n
	ans = max(ans, s2)
	s -= a.pop()
	n -= 1
	m -= 1
print(ans)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
p = sum(a)
ans = (p + min(n * k, m)) / n
for i in range(0, min(n - 1, m)):
	p -= a[i]
	n1 = n - i - 1
	ans = max(ans, (p + min(m - i - 1, k * n1)) / n1)
print(ans)


if True:
	(n, k, m) = tuple(map(int, input().split()))
	a = list(map(int, input().split()))
else:
	(n, k, m) = (1000, 2, 40)
	a = list(range(n))
a.sort(reverse=True)
middle_power = sum(a)
num = n
for i in range(n - 1, 0, -1):
	if (middle_power - a[i] + min(m - 1, k * (num - 1))) / (num - 1) > (middle_power + min(m, k * num)) / num:
		middle_power -= a[i]
		m -= 1
		num -= 1
	else:
		break
	if m == 0:
		break
print((middle_power + min(m, k * num)) / num)


(n, k, m) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
sum = 0
for i in arr:
	sum = sum + i
mx = 0
for i in range(len(arr)):
	if i > m:
		break
	mx = max(mx, (sum + min(m - i, (n - i) * k)) / (n - i))
	sum = sum - arr[i]
print(mx)


(n, k, m) = [int(x) for x in input().split(' ')]
s = [int(x) for x in input().split(' ')]
res = 0
somme = 0
s.sort(reverse=True)
j = m
while len(s) > 1 and j > 0 and (s[0] - s[-1] > 1 or j > len(s)):
	s.pop()
	j = j - 1
x1 = s.count(max(s))
x2 = s.count(min(s))
if x1 >= x2 and max(s) - min(s) != 0 and (j > 0):
	s.pop()
	j = j - 1
somme = sum(s)
y = len(s)
while j > 0 and y > 0:
	if j >= k:
		somme = somme + k
		j = j - k
		y = y - 1
	else:
		somme = somme + j
		break
res = somme / len(s)
print(res)


def main():
	(n, k, m) = map(int, input().split())
	heroes = [x for x in map(int, input().split())]
	heroes.sort()
	cbk = min(m, n)
	m -= cbk
	for i in range(cbk):
		heroes[i] += 1
	heroes.reverse()
	for i in range(n):
		used = min(m, k - 1)
		heroes[i] += used
		m -= used
	(pf, tot) = ([], 0)
	for i in range(n):
		tot += heroes[i]
		pf += [tot]
	ave = [pf[i] / (i + 1) for i in range(n)]
	print(max(ave[-min(n, cbk + 1):]))
main()


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort(reverse=True)
partial = [0]
for val in a:
	partial.append(partial[-1] + val)
best = 0.0
for num_remove in range(0, min(n, m + 1)):
	num_operations = m - num_remove
	num_remain = n - num_remove
	num_increase = min(num_operations, num_remain * k)
	average = (partial[num_remain] + num_increase) / num_remain
	best = max(best, average)
print(best)


import sys
from collections import Counter

def input():
	return sys.stdin.readline().strip()

def dinput():
	return int(input())

def tinput():
	return input().split()

def rinput():
	return map(int, tinput())

def rtinput():
	return map(float, tinput())

def main():
	(a, s, d) = rinput()
	q = sorted(list(rtinput()))
	w = [0]
	for i in range(a):
		w.append(w[i] + q[i])
	z = -1.0
	for i in range(min(d + 1, a)):
		z = max(z, float(w[a] - w[i] + min(d - i, (a - i) * s)) / (a - i))
	print('{:.6f}'.format(z))
main()


def main():
	(n, k, m) = map(int, input().split())
	a = sorted([int(i) for i in input().split()])
	s = sum(a)
	ans = (min(m, n * k) + s) / n
	for i in range(1, min(n, m + 1)):
		s -= a[i - 1]
		ans = max((s + min(m - i, (n - i) * k)) / (n - i), ans)
	print(ans)
main()


(n, k, m) = map(int, input().split())
a = sorted(map(int, input().split()))
s = sum(a)
ans = 0.0
for i in range(n):
	ans = max(ans, (s + min((n - i) * k, m)) / (n - i))
	s -= a[i]
	if m == 0:
		break
	m -= 1
print('%.8f' % ans)


(n, k, m) = map(int, input().split())
a = sorted(list(map(int, input().split())))
s = sum(a)
ans = -1
for i in range(min(n, m + 1)):
	avg = (s + min(k * (n - i), m - i)) / (n - i)
	ans = max(avg, ans)
	s -= a[0]
	del a[0]
print(ans)


(n, k, m) = map(int, input().split())
s = r = 0
a = list(map(int, input().split()))
a.sort()
if m >= n:
	print(a[n - 1] + min(m - n + 1, k))
else:
	for i in range(0, n):
		s += a[i]
	s += m
	r = s / n
	for i in range(0, m):
		r = max(r, (s - a[i] - i - 1) / (n - i - 1))
		s -= a[i]
	print(r)


[n, k, m] = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
s = sum(a)
res = [(s + min(n * k, m)) / n]
for i in range(1, n):
	s -= a[i - 1]
	if m < i:
		break
	res.append((s + min(m - i, (n - i) * k)) / (n - i))
print(max(res))


(n, k, m) = map(int, input().split())
aa = list(map(int, input().split()))
aa.sort()
s = sum(aa)
mx = (s + min(m, n * k)) / n
for start in range(min(n - 1, m)):
	s -= aa[start]
	tmp = s + min(m - start - 1, (n - start - 1) * k)
	mx = max(mx, tmp / (n - start - 1))
print(mx)


(n, k, m) = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
s = sum(l)
maxavg = (s + min(m, n * k)) / n
for i in range(min(n - 1, m)):
	s = s - l[i]
	newsum = s + min(m - i - 1, (n - i - 1) * k)
	newavg = newsum / (n - i - 1)
	maxavg = max(maxavg, newavg)
print(maxavg)


import sys
input = sys.stdin.readline
(n, k, m) = [int(x) for x in input().split()]
a = sorted([int(x) for x in input().split()])
s = sum(a)
mx = (s + min(m, n * k)) / n
for i in range(min(m, n - 1)):
	s -= a[i]
	mx = max(mx, (s + min(m - i - 1, (n - i - 1) * k)) / (n - i - 1))
print(mx)


(n, k, m) = map(int, input().split())
t = list(map(int, input().split()))
s = sum(t)
if n == 1:
	print('{0:.6f}'.format(min(s + k, s + m)))
elif k * n <= m:
	print('{0:.6f}'.format(max(t) + k))
else:
	t.sort()
	t = [0] + t
	max_avg = s / n
	remove = 0
	for i in range(min(n, m + 1)):
		remove += t[i]
		max_avg = max(max_avg, (s - remove + min(m - i, k * (n - i))) / (n - i))
	print('{0:.6f}'.format(max_avg))


(n, m, k) = map(int, input().split())
a = list(map(int, input().split()))
a.sort(reverse=True)
s = [] + a
if m * n < k:
	s = a[:max(1, n - k + m * n)]
s1 = (sum(s) + min(m * len(s), k)) / len(s)
if k >= n - 1:
	ind = n - 1 - a[::-1].index(max(a))
	l = a[:max(n - k, ind + 1)]
	sd = min(m * len(l), k - (n - len(l)))
	l1 = a[0]
	k -= n - 1
	l1 += min(k, m)
	print(max(s1, l1, (sum(l) + sd) / len(l)))
else:
	ind = n - 1 - a[::-1].index(max(a))
	l = a[:max(n - k, ind + 1)]
	sd = k - (n - len(l))
	l1 = a[:n - k]
	s2 = sum(l1) / (n - k)
	print(max(s1, s2, (sum(l) + sd) / len(l)))


(n, lim, total) = map(int, input().split())
a = sorted(map(int, input().split()))
psums = [0, a[0]]
for i in range(1, n):
	psums.append(psums[i] + a[i])

def rangeSum(left, right):
	return psums[right + 1] - psums[left]
ret = 0
for nDel in range(min(total + 1, n)):
	rem = n - nDel
	power = (min(rem * lim, total - nDel) + rangeSum(nDel, n - 1)) / rem
	ret = max(ret, power)
print(ret)


(n, k, m) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
(curn, curs) = (n, sum(a))
ans = (curs + min(k * curn, m)) / curn
for i in range(n - 1):
	if i + 1 > m:
		break
	curn -= 1
	curs -= a[i]
	ans = max(ans, (curs + min(k * curn, m - i - 1)) / curn)
print('%.8f' % ans)


(n, k, m) = [int(c) for c in input().split()]
a = [int(c) for c in input().split()]
a.sort()
sm = sum(a)
pref = [i for i in range(n + 1)]
for i in range(1, n + 1):
	pref[i] = pref[i - 1] + a[i - 1]
(avg, mx) = (0, -1)
for i in range(min(m, n - 1) + 1):
	sm_of_left = sm - pref[i]
	avg = (sm_of_left + min(m - i, k * (n - i))) / (n - i)
	if avg > mx:
		mx = avg
print(mx)