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.

Difficulty: interview

Starter code:

Solutions:
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)


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 = [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)


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)

import sys
input = sys.stdin.readline

n,k,m=list(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,SUM)

print(ANS)
    


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()

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)):
	# Remove i the i less powerful superheroes
	if i > 0:
		ss = ss - A[i-1]

	maxadvg = min(K*(N-i), M-i)

	maxavg = max(maxavg, (ss+maxadvg) / (N-i))

print(maxavg)

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=list(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)






































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))


def __starting_point():
    main()

__starting_point()

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)

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())
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)

''' CODED WITH LOVE BY SATYAM KUMAR '''


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) # max depth of recursion
threading.stack_size(2**27)  # new thread will get stack of such size
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, 1e9)
max_operation = Operation("max", max, max_multiple, -1e9)
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): #n**0.5 complex 
    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):
    """Returns True if n is prime."""
    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 = []                         # list of entries arranged in a heap
entry_finder = {}               # mapping of tasks to entries
REMOVED = '<removed-task>' 
def add_task(task, priority=0):
    'Add a new task or update the priority of an existing task'
    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):
    'Mark an existing task as REMOVED.  Raise KeyError if not found.'
    entry = entry_finder.pop(task)
    entry[-1] = REMOVED

def pop_task():
    'Remove and return the lowest priority task. Raise KeyError if empty.'
    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


# -------------------------------------------------------------- MAIN PROGRAM
TestCases = False
testingMode = False
fac_warmup_size = 10**5+100
optimiseForReccursion = True #Can not be used clubbed with TestCases
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)
    #print(sm)
    li.reverse()
    #print(li)
    res = 0
    i=0
    while m>=0 and i<n:
        res = max(res, sm[i]+min(m/(n-i),k))
        #print(i,m, res)
        i+=1
        m-=1
    print(res)

# --------------------------------------------------------------------- END=


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()


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(dyn_avg)
	print(maxavg)
	# for i in range(len(a)):



def __starting_point():
	main()
__starting_point()

import  sys
n, k, m = [int(i) for i in input().split(' ')]
#
# def helper(pows, k, m):
#     res = -sys.maxsize
#     def dfs(cur, cur_o, sums, sum_o):
#         if sum_o >= m:
#             return
#         for i, num in enumerate(cur):
#             dfs(cur)

def helper(pows, k, m):
    res = -sys.maxsize
    pref = [0]
    for i in range(len(pows)):
        pref.append(pref[-1] + pows[i])
    # print(pref)
    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))
        # print(res, i)
    return res




pows = [int(i) for i in input().split(' ')]
pows.sort()
print(helper(pows, k, m))


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)

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())
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()))
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)


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)
            else:
                if 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 = 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)

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())
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)