#include <vector>
#include <iostream>
#include <string>
#include <numeric>
#include <cmath>
#include <limits>
#include <iomanip>
#include <algorithm>
#include <map>
#include <queue>
#include <set>

#define bit(x) (1 << (x))
#define sz(x) int((x).size())
#define all(x) (x).begin(), (x).end()
#define alln(x, n) (x).begin(), (x).begin()+n
#define forn(i, n) for (ll i = 0; i < n; i++)

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int inf = 998244353;

ll n, t, k;
string a;

vi sizes(11);
vector<ll> tens(19);
vi nums(11);

void solve() {
    cin >> n;
    forn (i, n) {
        cin >> a;
        sizes[sz(a)-1]++;
        for (int j = 0; j < sz(a); j++) {
            nums[j] += a[sz(a)-1 - j] - '0';
        }
    }

    //forn (i, 10) cout << i << " " << nums[i] << endl;
    //cout << "sizes" << endl;
    //forn (i, 10) cout << i << " " << sizes[i] << endl;

    //cout << "Rest" << endl;

    ll sol = 0;
    for (int i = 0; i < 11; i++) {         // nums
        for (int j = i; j < 11; j++) {     // size
           sol += (tens[i*2] * nums[i] * sizes[j]) % inf;
           sol += (tens[i*2+1] * nums[i] * sizes[j]) % inf;
           sol %= inf;
        }
        for (int j = 0; j < i; j++) {
            sol += 0;
        }
    }
    cout << sol << endl;

}

int main() {
    tens[0] = 1;
    for (int i = 1; i < 19; i++) tens[i] = (tens[i-1]*10) % inf;

    solve();
}


#include <vector>
#include <iostream>
#include <string>
#include <numeric>
#include <cmath>
#include <limits>
#include <iomanip>
#include <algorithm>
#include <map>
#include <queue>
#include <set>

#define bit(x) (1 << (x))
#define sz(x) int((x).size())
#define all(x) (x).begin(), (x).end()
#define alln(x, n) (x).begin(), (x).begin()+n
#define forn(i, n) for (ll i = 0; i < n; i++)

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int inf = 998244353;

ll n, t, k;
string a;

vi sizes(11);
vector<ll> tens(21);
vi nums(11);

void solve() {
    cin >> n;
    forn (i, n) {
        cin >> a;
        sizes[sz(a)-1]++;
        for (int j = 0; j < sz(a); j++) {
            nums[j] += a[sz(a)-1 - j] - '0';
        }
    }

    forn (i, 10) cout << i << " " << nums[i] << endl;
    cout << "sizes" << endl;
    forn (i, 10) cout << i << " " << sizes[i] << endl;

    //cout << "Rest" << endl;

    ll sol = 0;
    for (int i = 0; i < 11; i++) {         // nums
        for (int j = i; j < 11; j++) {     // size
           sol += (tens[i*2]) * ((nums[i] * sizes[j]) % inf);
           sol += (tens[i*2+1]) * ((nums[i] * sizes[j]) % inf);
           sol %= inf;
        }
        for (int j = 0; j < i; j++) {
            sol += 0;
        }
    }
    cout << sol << endl;

}

int main() {
    tens[0] = 1;
    for (int i = 1; i < 21; i++) tens[i] = (tens[i-1]*10) % inf;

    solve();
}


#include <vector>
#include <iostream>
#include <string>
#include <numeric>
#include <cmath>
#include <limits>
#include <iomanip>
#include <algorithm>
#include <map>
#include <queue>
#include <set>

#define bit(x) (1 << (x))
#define sz(x) int((x).size())
#define all(x) (x).begin(), (x).end()
#define alln(x, n) (x).begin(), (x).begin()+n
#define forn(i, n) for (ll i = 0; i < n; i++)

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int inf = 998244353;

ll n, t, k;
string a;

vi sizes(11);
vector<ll> tens(19);
vi nums(10);

void solve() {
    cin >> n;
    forn (i, n) {
        cin >> a;
        sizes[sz(a)-1]++;
        for (int j = 0; j < sz(a); j++) {
            nums[j] += a[sz(a)-1 - j] - '0';
        }
    }

    forn (i, 10) cout << i << " " << nums[i] << endl;
    cout << "sizes" << endl;
    forn (i, 10) cout << i << " " << sizes[i] << endl;

    cout << "Rest" << endl;

    ll sol = 0;
    for (int i = 0; i < 10; i++) {         // nums
        for (int j = i; j < 3; j++) {     // size
           printf("%d %lld\n", nums[i], sizes[j]);
           sol += (tens[i*2] * nums[i] * sizes[j]) % inf;
           sol += (tens[i*2+1] * nums[i] * sizes[j]) % inf;
           sol %= inf;
        }
        for (int j = 0; j < i; j++) {
            sol += 0;
        }
    }
    cout << sol << endl;

}

int main() {
    tens[0] = 1;
    for (int i = 1; i < 19; i++) tens[i] = tens[i-1]*10;

    solve();
}


#include <vector>
#include <iostream>
#include <string>
#include <numeric>
#include <cmath>
#include <limits>
#include <iomanip>
#include <algorithm>
#include <map>
#include <queue>
#include <set>

#define bit(x) (1 << (x))
#define sz(x) int((x).size())
#define all(x) (x).begin(), (x).end()
#define alln(x, n) (x).begin(), (x).begin()+n
#define forn(i, n) for (ll i = 0; i < n; i++)

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int inf = 998244353;

ll n, t, k;
string a;

vi sizes(15);
vector<ll> tens(21);
vi nums(15);

void solve() {
    cin >> n;
    forn (i, n) {
        cin >> a;
        sizes[sz(a)-1]++;
        for (int j = 0; j < sz(a); j++) {
            nums[j] += a[sz(a)-1 - j] - '0';
        }
    }

    // forn (i, 10) cout << i << " " << nums[i] << endl;
    // cout << "sizes" << endl;
    // forn (i, 10) cout << i << " " << sizes[i] << endl;

    //cout << "Rest" << endl;

    ll sol = 0;
    for (int i = 0; i < 11; i++) {         // nums
        for (int j = i; j < 11; j++) {     // size
           sol += (tens[i*2]) * ((nums[i] * sizes[j]) % inf);
           sol += (tens[i*2+1]) * ((nums[i] * sizes[j]) % inf);
           sol %= inf;
        }
        for (int j = 0; j < i; j++) {
            sol += 0;
        }
    }
    cout << sol << endl;

}

int main() {
    tens[0] = 1;
    for (int i = 1; i < 21; i++) tens[i] = (tens[i-1]*10) % inf;

    solve();
}


#include <vector>
#include <iostream>
#include <string>
#include <numeric>
#include <cmath>
#include <limits>
#include <iomanip>
#include <algorithm>
#include <map>
#include <queue>
#include <set>

#define bit(x) (1 << (x))
#define sz(x) int((x).size())
#define all(x) (x).begin(), (x).end()
#define alln(x, n) (x).begin(), (x).begin()+n
#define forn(i, n) for (ll i = 0; i < n; i++)

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int inf = 998244353;

ll n, t, k;
string a;

vector<ll> sizes(15);
vector<ll> tens(21);
vector<ll> nums(15);

void solve() {
    cin >> n;
    forn (i, n) {
        cin >> a;
        sizes[sz(a)-1]++;
        for (int j = 0; j < sz(a); j++) {
            nums[j] += a[sz(a)-1 - j] - '0';
        }
    }

    // forn (i, 10) cout << i << " " << nums[i] << endl;
    // cout << "sizes" << endl;
    // forn (i, 10) cout << i << " " << sizes[i] << endl;

    //cout << "Rest" << endl;

    ll sol = 0;
    for (int i = 0; i < 11; i++) {         // nums
        for (int j = i; j < 11; j++) {     // size
           sol += (tens[i*2]) * ((nums[i] * sizes[j]) % inf);
           sol += (tens[i*2+1]) * ((nums[i] * sizes[j]) % inf);
           sol %= inf;
        }
        for (int j = 0; j < i; j++) {
            sol += 0;
        }
    }
    cout << sol << endl;

}

int main() {
    tens[0] = 1;
    for (int i = 1; i < 21; i++) tens[i] = (tens[i-1]*10) % inf;

    solve();
}


#include<bits/stdc++.h>

using namespace std;

typedef unsigned long long int ll;

ll M = 998244353;
ll power(ll a , ll n)
{
    unsigned long long int result=1,x=a;
    while(n>0)
    {
        if(n % 2 ==1)
            result=(result * x)%M;
        x = (x * x)%M;
        n=n/2;
    }
    return result%M;
}

int main()
{
    int n;
    cin >> n;
    ll a[n];
    for(int i=0 ; i<n ; i++)
        cin >> a[i];

    string s = to_string(a[0]);

    ll m = s.length();
    ll b[m]={0};

    for(int i=0 ; i<n ; i++)
    {
        string s1 = to_string(a[i]);
        for(int j=0 ; j<s1.length() ; j++)
            b[j] += s1[j]-'0';
    }
    //for(int i=0 ; i<m ; i++)
      //  cout << b[i] << " ";
    string ans="";
    ll carry=0;
    for(int i=m-1 ; i>=0 ; i--)
    {
         ll p = (b[i]*n)+carry;
         if(p>9)
         {
             carry = p/10;
             char ka = p%10 + '0';
             ans = ka + ans;
         }
         else
         {
             carry = 0;
             char ka = p + '0';
             ans = ka + ans;
         }
          p = (b[i]*n)+carry;
         if(p>9)
         {
             carry = p/10;
             char ka = p%10 + '0';
             ans = ka + ans;
         }
         else
         {
             carry = 0;
             char ka = p + '0';
             ans = ka + ans;
         }
    }
    if(carry!=0)
    {
        string s2 = to_string(carry);
        ans = s2+ans;
    }

    ll fine=0;
    for(int i=ans.length()-1 ; i>=0 ; i--)
    {
         fine = (fine + ((ans[i]-'0')*power(10,ans.length()-i-1))%M)%M;
    }
    cout << fine;
    return 0;
}


#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;

int main()
{
    int n;
    cin >> n;
    ll a[n];
    for(int i=0 ; i<n ; i++)
        cin >> a[i];

    string s = to_string(a[0]);

    int m = s.length();
    int b[m]={0};

    for(int i=0 ; i<n ; i++)
    {
        string s1 = to_string(a[i]);
        for(int j=0 ; j<s1.length() ; j++)
            b[j] += s1[j]-'0';
    }
    //for(int i=0 ; i<m ; i++)
      //  cout << b[i] << " ";
    string ans="";
    int carry=0;
    for(int i=m-1 ; i>=0 ; i--)
    {
         ll p = (b[i]*n)+carry;
         if(p>9)
         {
             carry = p/10;
             char ka = p%10 + '0';
             ans = ka + ans;
         }
         else
         {
             carry = 0;
             char ka = p + '0';
             ans = ka + ans;
         }
          p = (b[i]*n)+carry;
         if(p>9)
         {
             carry = p/10;
             char ka = p%10 + '0';
             ans = ka + ans;
         }
         else
         {
             carry = 0;
             char ka = p + '0';
             ans = ka + ans;
         }
    }
    if(carry!=0)
    {
        char ka = carry+'0';
        ans = ka+ans;
    }
    cout << ans;
    return 0;
}


#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;

ll M = 998244353;
ll power(ll a , ll n)
{
    unsigned long long int result=1,x=a;
    while(n>0)
    {
        if(n % 2 ==1)
            result=(result * x)%M;
        x = (x * x)%M;
        n=n/2;
    }
    return result%M;
}

int main()
{
    int n;
    cin >> n;
    ll a[n];
    for(int i=0 ; i<n ; i++)
        cin >> a[i];

    string s = to_string(a[0]);

    int m = s.length();
    int b[m]={0};

    for(int i=0 ; i<n ; i++)
    {
        string s1 = to_string(a[i]);
        for(int j=0 ; j<s1.length() ; j++)
            b[j] += s1[j]-'0';
    }
    //for(int i=0 ; i<m ; i++)
      //  cout << b[i] << " ";
    string ans="";
    ll carry=0;
    for(int i=m-1 ; i>=0 ; i--)
    {
         ll p = (b[i]*n)+carry;
         if(p>9)
         {
             carry = p/10;
             char ka = p%10 + '0';
             ans = ka + ans;
         }
         else
         {
             carry = 0;
             char ka = p + '0';
             ans = ka + ans;
         }
          p = (b[i]*n)+carry;
         if(p>9)
         {
             carry = p/10;
             char ka = p%10 + '0';
             ans = ka + ans;
         }
         else
         {
             carry = 0;
             char ka = p + '0';
             ans = ka + ans;
         }
    }
    if(carry!=0)
    {
        char ka = carry+'0';
        ans = ka+ans;
    }
    //cout << ans;
    ll fine=0;
    for(int i=ans.length()-1 ; i>=0 ; i--)
    {
         fine = (fine + ((ans[i]-'0')*power(10,ans.length()-i-1))%M)%M;
    }
    cout << fine;
    return 0;
}


#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;

ll M = 998244353;
ll power(ll a , ll n)
{
    unsigned long long int result=1,x=a;
    while(n>0)
    {
        if(n % 2 ==1)
            result=(result * x)%M;
        x = (x * x)%M;
        n=n/2;
    }
    return result%M;
}

int main()
{
    int n;
    cin >> n;
    ll a[n];
    for(int i=0 ; i<n ; i++)
        cin >> a[i];

    string s = to_string(a[0]);

    ll m = s.length();
    ll b[m]={0};

    for(int i=0 ; i<n ; i++)
    {
        string s1 = to_string(a[i]);
        for(int j=0 ; j<s1.length() ; j++)
            b[j] += s1[j]-'0';
    }
    //for(int i=0 ; i<m ; i++)
      //  cout << b[i] << " ";
    string ans="";
    ll carry=0;
    for(int i=m-1 ; i>=0 ; i--)
    {
         ll p = (b[i]*n)+carry;
         if(p>9)
         {
             carry = p/10;
             char ka = p%10 + '0';
             ans = ka + ans;
         }
         else
         {
             carry = 0;
             char ka = p + '0';
             ans = ka + ans;
         }
          p = (b[i]*n)+carry;
         if(p>9)
         {
             carry = p/10;
             char ka = p%10 + '0';
             ans = ka + ans;
         }
         else
         {
             carry = 0;
             char ka = p + '0';
             ans = ka + ans;
         }
    }
    if(carry!=0)
    {
        char ka = carry+'0';
        ans = ka+ans;
    }
    //cout << ans;
    ll fine=0;
    for(int i=ans.length()-1 ; i>=0 ; i--)
    {
         fine = (fine + ((ans[i]-'0')*power(10,ans.length()-i-1))%M)%M;
    }
    cout << fine;
    return 0;
}


#include<bits/stdc++.h>

using namespace std;

typedef unsigned long long int ll;

ll M = 998244353;
ll power(ll a , ll n)
{
    unsigned long long int result=1,x=a;
    while(n>0)
    {
        if(n % 2 ==1)
            result=(result * x)%M;
        x = (x * x)%M;
        n=n/2;
    }
    return result%M;
}

int main()
{
    int n;
    cin >> n;
    ll a[n];
    for(int i=0 ; i<n ; i++)
        cin >> a[i];

    string s = to_string(a[0]);

    ll m = s.length();
    ll b[m]={0};

    for(int i=0 ; i<n ; i++)
    {
        string s1 = to_string(a[i]);
        for(int j=0 ; j<s1.length() ; j++)
            b[j] += s1[j]-'0';
    }
    //for(int i=0 ; i<m ; i++)
      //  cout << b[i] << " ";
    string ans="";
    ll carry=0;
    for(int i=m-1 ; i>=0 ; i--)
    {
         ll p = (b[i]*n)+carry;
         if(p>9)
         {
             carry = p/10;
             char ka = p%10 + '0';
             ans = ka + ans;
         }
         else
         {
             carry = 0;
             char ka = p + '0';
             ans = ka + ans;
         }
          p = (b[i]*n)+carry;
         if(p>9)
         {
             carry = p/10;
             char ka = p%10 + '0';
             ans = ka + ans;
         }
         else
         {
             carry = 0;
             char ka = p + '0';
             ans = ka + ans;
         }
    }
    if(carry!=0)
    {
        char ka = carry+'0';
        ans = ka+ans;
    }
    //cout << ans;
    ll fine=0;
    for(int i=ans.length()-1 ; i>=0 ; i--)
    {
         fine = (fine + ((ans[i]-'0')*power(10,ans.length()-i-1))%M)%M;
    }
    cout << fine;
    return 0;
}


#include <iostream>
#include <cstdio>

using namespace std;
const long long MOD = 998244353;
int n;
long long y, ans;
string x;
int main()
{
    scanf("%d",&n);
    for (int i=1;i<=n;i++){
        scanf("%s",&x);
        y=0;
        for (int i=0;i<(int)x.size();i++){
            y*=100;
            y+= (x[i]-'0')*10+(x[i]-'0');
            y%=MOD;
        }
        ans = (ans + ((y%MOD)*(n%MOD))%MOD )%MOD;
    }
    cout<<ans;
    return 0;
}


#include <iostream>
#include <cstdio>

using namespace std;
const long long MOD = 998244353;
int n;
long long y, ans;
string x;
int main()
{
    cin.tie(0);
    ios::sync_with_stdio(0);
    cin>>n;
    for (int i=1;i<=n;i++){
        cin>>x;
        y=0;
        for (int i=0;i<(int)x.size();i++){
            y*=100;
            y+= (x[i]-'0')*10+(x[i]-'0');
            y%=MOD;
        }
        ans = (ans + ((y%MOD)*(n%MOD))%MOD )%MOD;
    }
    cout<<ans;
    return 0;
}


#include <iostream>
#include <cstdio>

using namespace std;
const long long MOD = 998244353;
int n;
long long y, ans;
string x;
int main()
{
    scanf("%d",&n);
    for (int i=1;i<=n;i++){
        scanf("%s",&x);
        y=0;
        for (int i=0;i<(int)x.size();i++){
            y*=100;
            y+= (x[i]-'0')*10+(x[i]-'0');
            y%=MOD;
        }
        ans = (ans + ((y%MOD)*(n%MOD))%MOD )%MOD;
    }
    printf("%lld",ans);
    return 0;
}


#include <iostream>
#include <cstdio>

using namespace std;
const long long MOD = 998244353;
int n;
long long y, ans;
string x;
int main()
{
    scanf("%d",&n);
    for (int i=1;i<=n;i++){
        scanf("%s",&x);
        y=0;
        for (int i=0;i<(int)x.size();i++){
            y*=100;
            y+= (x[i]-'0')*10+(x[i]-'0');
            y%=MOD;
        }
        ans = (ans + ((y%MOD)*(n%MOD))%MOD )%MOD;
    }
    printf("%ld",ans);
    return 0;
}


using System;
using System.Linq;

namespace B573
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] nm = Console.ReadLine().Split().Select(x => int.Parse(x)).ToArray();
            int[] A = Console.ReadLine().Split().Select(x => int.Parse(x)).ToArray();
            int[] sum = new int[nm[0]];
            Array.Sort(A);
            sum[0] = A[0];
            for(int i = 1; i < nm[0]; ++i)
                sum[i] = sum[i-1] + A[i];

            double ini = 0;
            double end = 10e8;
            while(Math.Abs(end - ini) >= 1e-12)
            {
                double m = (ini + end) / 2.0;
                if(CanBe(m, nm, sum, A))
                    ini = m;
                else
                    end = m;
            }
            System.Console.WriteLine(ini);
        }

        private static bool CanBe(double average, int[] nm, int[] sum, int[] A)
        {
            int n = nm[0];
            int k = nm[1];
            int m = nm[2];
            double sm = sum[nm[0] - 1];
            int idx = 0;
            for(int i = 0; i < nm[0]; ++i)
            {
                double av = (sm + Math.Min(m - i, n * k) * 1.0) / n;
                if(av - average >= 1e-12)
                    return true;
                sm -= (double)A[idx++];
                --n;
            }
            return false;
        }
    }
}


using System;
using System.Linq;

namespace B573
{
    class Program
    {
        static void Main(string[] args)
        {
            long[] nm = Console.ReadLine().Split().Select(x => long.Parse(x)).ToArray();
            long[] A = Console.ReadLine().Split().Select(x => long.Parse(x)).ToArray();
            double sum = 0;
            Array.Sort(A);
            for(int i = 0; i < nm[0]; ++i)
                sum += A[i];

            double sol = 0;
            for(int i = 0; i < A.Length && nm[2] - i >= 0; --nm[0], sum -= A[i], ++i)
                sol = Math.Max((sum + Math.Min(nm[1] * nm[0], nm[2] - i)) / nm[0], sol);

            System.Console.WriteLine(sol.ToString(".##########0"));
        }
    }
}


using System;
using System.Linq;

namespace B573
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] nm = Console.ReadLine().Split().Select(x => int.Parse(x)).ToArray();
            int[] A = Console.ReadLine().Split().Select(x => int.Parse(x)).ToArray();
            int sum = 0;
            Array.Sort(A);
            for(int i = 0; i < nm[0]; ++i)
                sum += A[i];

            double ini = 0;
            double end = 10e8;
            while(end - ini >= 1e-7)
            {
                double m = (ini + end) / 2.0;
                if(CanBe(m, nm, sum, A))
                    ini = m;
                else
                    end = m;
            }
            System.Console.WriteLine(ini);
        }

        private static bool CanBe(double average, int[] nm, int sum, int[] A)
        {
            int n = nm[0];
            int k = nm[1];
            int m = nm[2];
            double sm = sum;
            int idx = 0;
            for(int i = 0; i < nm[0]; ++i)
            {
                double av = (sm + Math.Min(m - i, n * k) * 1.0) / n;
                if(av - average >= 1e-12)
                    return true;
                sm -= (double)A[idx++];
                --n;
            }
            return false;
        }
    }
}


using System;
using System.Linq;

namespace B573
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] nm = Console.ReadLine().Split().Select(x => int.Parse(x)).ToArray();
            int[] A = Console.ReadLine().Split().Select(x => int.Parse(x)).ToArray();
            double sum = 0;
            Array.Sort(A);
            for(int i = 0; i < nm[0]; ++i)
                sum += A[i];

            double ini = 0;
            double end = 10e8;
            while(end - ini >= 1e-8)
            {
                double m = (ini + end) / 2.0;
                if(CanBe(m, nm, sum, A))
                    ini = m;
                else
                    end = m;
            }
            System.Console.WriteLine(ini);
        }

        private static bool CanBe(double average, int[] nm, double sum, int[] A)
        {
            int n = nm[0];
            int k = nm[1];
            int m = nm[2];
            double sm = sum;
            int idx = 0;
            for(int i = 0; i < nm[0]; ++i)
            {
                double av = (sm + Math.Min((long)(m - i), (long)(n * k)) * 1.0) / n;
                if(av - average > 1e-12)
                    return true;
                sm -= (double)A[idx++];
                --n;
            }
            return false;
        }
    }
}


using System;
using System.Linq;
using System.Collections.Generic;

static class UtilityMethods
{
	public static void Swap<T>(ref T a, ref T b)
	{
		T t = a;
		a = b;
		b = t;
	}

	public static int StrToInt(string s)
	{
		int number = 0;
		for (int i = s[0] == '-' ? 1 : 0; i < s.Length; i++)
			number = number * 10 + (s[i] - '0');
		return s[0] == '-' ? -number : number;
	}
	public static long StrToLong(string s)
	{
		long number = 0;
		for (int i = s[0] == '-' ? 1 : 0; i < s.Length; i++)
			number = number * 10 + (s[i] - '0');
		return s[0] == '-' ? -number : number;
	}

	public static string ReadString() => Console.ReadLine();
	public static int ReadInt() => StrToInt(ReadString());
	public static long ReadLong() => StrToLong(ReadString());
	public static double ReadDouble() => double.Parse(ReadString());

	public static string[] ReadStringArray() => ReadString().Split();
	public static int[] ReadIntArray() => Array.ConvertAll(ReadStringArray(), StrToInt);
	public static long[] ReadLongArray() => Array.ConvertAll(ReadStringArray(), StrToLong);
	public static double[] ReadDoubleArray() => ReadStringArray().Select(double.Parse).ToArray();

	public static void WriteLine(object a) => Console.WriteLine(a);
	public static void WriteLineArray<T>(string separator, T[] a, int startIndex, int count)
	{
		const int MAXLEN = 1000000;
		int len = 0, j = startIndex, lastIndex = startIndex + count;
		System.Text.StringBuilder str;
		string[] b = Array.ConvertAll(a, x => x.ToString());
		for (int i = startIndex; i < lastIndex - 1; i++)
		{
			len += b[i].Length + separator.Length;
			if (len >= MAXLEN)
			{
				str = new System.Text.StringBuilder(len);
				for (; j <= i; j++)
				{
					str.Append(b[j]);
					str.Append(separator);
				}
				Console.Write(str);
				len = 0;
			}
		}
		str = new System.Text.StringBuilder(len);
		for (; j < lastIndex - 1; j++)
		{
			str.Append(b[j]);
			str.Append(separator);
		}
		Console.Write(str);
		Console.WriteLine(b.Last());
	}
}

class Program
{
	static void Main()
	{
		int[] data = UtilityMethods.ReadIntArray();
		int n = data[0], k = data[1], m = data[2];
		double[] a = UtilityMethods.ReadDoubleArray();
		Array.Sort(a);
		double sum = a.Sum(), ans = (sum + Math.Min(m, k * n)) / n, subSum = 0;
		for (int i = 0; i < n - 1; i++)
		{
			if (m == 0)
				break;
			subSum += a[i];
			m--;
			ans = Math.Max(ans, (sum - subSum + m) / (n - i - 1));
		}
		UtilityMethods.WriteLine(Math.Min(ans, a[n - 1] + k));
		Console.ReadLine();
	}
}


using System;
using System.Linq;
using System.Collections.Generic;

static class UtilityMethods
{
	public static void Swap<T>(ref T a, ref T b)
	{
		T t = a;
		a = b;
		b = t;
	}

	public static int StrToInt(string s)
	{
		int number = 0;
		for (int i = s[0] == '-' ? 1 : 0; i < s.Length; i++)
			number = number * 10 + (s[i] - '0');
		return s[0] == '-' ? -number : number;
	}
	public static long StrToLong(string s)
	{
		long number = 0;
		for (int i = s[0] == '-' ? 1 : 0; i < s.Length; i++)
			number = number * 10 + (s[i] - '0');
		return s[0] == '-' ? -number : number;
	}

	public static string ReadString() => Console.ReadLine();
	public static int ReadInt() => StrToInt(ReadString());
	public static long ReadLong() => StrToLong(ReadString());
	public static double ReadDouble() => double.Parse(ReadString());

	public static string[] ReadStringArray() => ReadString().Split();
	public static int[] ReadIntArray() => Array.ConvertAll(ReadStringArray(), StrToInt);
	public static long[] ReadLongArray() => Array.ConvertAll(ReadStringArray(), StrToLong);
	public static double[] ReadDoubleArray() => ReadStringArray().Select(double.Parse).ToArray();

	public static void WriteLine(object a) => Console.WriteLine(a);
	public static void WriteLineArray<T>(string separator, T[] a, int startIndex, int count)
	{
		const int MAXLEN = 1000000;
		int len = 0, j = startIndex, lastIndex = startIndex + count;
		System.Text.StringBuilder str;
		string[] b = Array.ConvertAll(a, x => x.ToString());
		for (int i = startIndex; i < lastIndex - 1; i++)
		{
			len += b[i].Length + separator.Length;
			if (len >= MAXLEN)
			{
				str = new System.Text.StringBuilder(len);
				for (; j <= i; j++)
				{
					str.Append(b[j]);
					str.Append(separator);
				}
				Console.Write(str);
				len = 0;
			}
		}
		str = new System.Text.StringBuilder(len);
		for (; j < lastIndex - 1; j++)
		{
			str.Append(b[j]);
			str.Append(separator);
		}
		Console.Write(str);
		Console.WriteLine(b.Last());
	}
}

class Program
{
	static void Main()
	{
		int[] data = UtilityMethods.ReadIntArray();
		int n = data[0], k = data[1], m = data[2];
		double[] a = UtilityMethods.ReadDoubleArray();
		Array.Sort(a);
		double sum = a.Sum(), ans = (sum + Math.Min(m, k * n)) / n, subSum = 0;
		for (int i = 0; i < n; i++)
		{
			if (m == 0)
				break;
			subSum += a[i];
			m--;
			ans = Math.Max(ans, (sum - subSum + m) / (n - i - 1));
		}
		UtilityMethods.WriteLine(Math.Min(ans, a[n - 1] + k));
		Console.ReadLine();
	}
}


using System;
using System.Linq;
using System.Collections.Generic;
using System.Diagnostics;
using Debug = System.Diagnostics.Trace;
using SB = System.Text.StringBuilder;
using System.Numerics;
using static System.Math;
using Number = System.Int64;
using N = System.Int64;
using C = System.Int32;
namespace Program {
	public class Solver {
		Random rnd = new Random();
		public void Solve() {
			var n = ri;
			var k = ri;
			var m = ri;
			var a = Enumerate(n, x => rl).OrderByDescending(x => x).ToArray();
			var s = 0L;
			var ans = -1.0;
			Debug.WriteLine(a.AsJoinedString());
			for (int i = 0; i < n; i++) {
				s += a[i];
				var rem = m - (n - i - 1);
				if (rem < 0) continue;
				var v = s;
				v += Min(rem, k * (i + 1L));
				Debug.WriteLine(rem);
				Debug.WriteLine($"{v} {v * 1.0 / (i + 1)}");
				ans = Max(ans, v * 1.0 / (i + 1));
			}
			Console.WriteLine(ans);
		}
		const long INF = 1L << 60;
		static int[] dx = { -1, 0, 1, 0 };
		static int[] dy = { 0, 1, 0, -1 };
		int ri { get { return sc.Integer(); } }
		long rl { get { return sc.Long(); } }
		double rd { get { return sc.Double(); } }
		string rs { get { return sc.Scan(); } }
		public IO.StreamScanner sc = new IO.StreamScanner(Console.OpenStandardInput());

		static T[] Enumerate<T>(int n, Func<int, T> f) {
			var a = new T[n];
			for (int i = 0; i < a.Length; ++i) a[i] = f(i);
			return a;
		}
		static public void Swap<T>(ref T a, ref T b) { var tmp = a; a = b; b = tmp; }
	}
}

#region main
static class Ex {
	static public string AsString(this IEnumerable<char> ie) { return new string(ie.ToArray()); }
	static public string AsJoinedString<T>(this IEnumerable<T> ie, string st = " ") {
		return string.Join(st, ie);
	}
	static public void Main() {
		//Console.SetOut(new Program.IO.Printer(Console.OpenStandardOutput()) { AutoFlush = false });
		var solver = new Program.Solver();
		solver.Solve();
		Console.Out.Flush();
	}
}
#endregion
#region Ex
namespace Program.IO {
	using System.IO;
	using System.Text;
	using System.Globalization;

	public class Printer : StreamWriter {
		public override IFormatProvider FormatProvider { get { return CultureInfo.InvariantCulture; } }
		public Printer(Stream stream) : base(stream, new UTF8Encoding(false, true)) { }
	}

	public class StreamScanner {
		public StreamScanner(Stream stream) { str = stream; }

		public readonly Stream str;
		private readonly byte[] buf = new byte[1024];
		private int len, ptr;
		public bool isEof = false;
		public bool IsEndOfStream { get { return isEof; } }

		private byte read() {
			if (isEof) return 0;
			if (ptr >= len) {
				ptr = 0;
				if ((len = str.Read(buf, 0, 1024)) <= 0) {
					isEof = true;
					return 0;
				}
			}
			return buf[ptr++];
		}

		public char Char() {
			byte b = 0;
			do b = read(); while ((b < 33 || 126 < b) && !isEof);
			return (char)b;
		}
		public string Scan() {
			var sb = new StringBuilder();
			for (var b = Char(); b >= 33 && b <= 126; b = (char)read()) sb.Append(b);
			return sb.ToString();
		}
		public string ScanLine() {
			var sb = new StringBuilder();
			for (var b = Char(); b != '\n' && b != 0; b = (char)read()) if (b != '\r') sb.Append(b);
			return sb.ToString();
		}
		public long Long() { return isEof ? long.MinValue : long.Parse(Scan()); }
		public int Integer() { return isEof ? int.MinValue : int.Parse(Scan()); }
		public double Double() { return isEof ? double.NaN : double.Parse(Scan(), CultureInfo.InvariantCulture); }
	}
}

#endregion


using System;
using System.Linq;
using System.Collections.Generic;
using System.Diagnostics;
using Debug = System.Diagnostics.Trace;
using SB = System.Text.StringBuilder;
using System.Numerics;
using static System.Math;
using Number = System.Int64;
using N = System.Int64;
using C = System.Int32;
namespace Program {
	public class Solver {
		Random rnd = new Random();
		public void Solve() {
			var n = ri;
			var k = ri;
			var m = ri;
			var a = Enumerate(n, x => rl).OrderByDescending(x => x).ToArray();
			var s = 0L;
			var ans = -1.0;
			for (int i = 0; i < n; i++) {
				s += a[i];
				var rem = m - i - 1;
				var v = s;
				v += Min(rem, k * (i + 1L));
				ans = Max(ans, v * 1.0 / (i + 1));
			}
			Console.WriteLine(ans);
		}
		const long INF = 1L << 60;
		static int[] dx = { -1, 0, 1, 0 };
		static int[] dy = { 0, 1, 0, -1 };
		int ri { get { return sc.Integer(); } }
		long rl { get { return sc.Long(); } }
		double rd { get { return sc.Double(); } }
		string rs { get { return sc.Scan(); } }
		public IO.StreamScanner sc = new IO.StreamScanner(Console.OpenStandardInput());

		static T[] Enumerate<T>(int n, Func<int, T> f) {
			var a = new T[n];
			for (int i = 0; i < a.Length; ++i) a[i] = f(i);
			return a;
		}
		static public void Swap<T>(ref T a, ref T b) { var tmp = a; a = b; b = tmp; }
	}
}

#region main
static class Ex {
	static public string AsString(this IEnumerable<char> ie) { return new string(ie.ToArray()); }
	static public string AsJoinedString<T>(this IEnumerable<T> ie, string st = " ") {
		return string.Join(st, ie);
	}
	static public void Main() {
		//Console.SetOut(new Program.IO.Printer(Console.OpenStandardOutput()) { AutoFlush = false });
		var solver = new Program.Solver();
		solver.Solve();
		Console.Out.Flush();
	}
}
#endregion
#region Ex
namespace Program.IO {
	using System.IO;
	using System.Text;
	using System.Globalization;

	public class Printer : StreamWriter {
		public override IFormatProvider FormatProvider { get { return CultureInfo.InvariantCulture; } }
		public Printer(Stream stream) : base(stream, new UTF8Encoding(false, true)) { }
	}

	public class StreamScanner {
		public StreamScanner(Stream stream) { str = stream; }

		public readonly Stream str;
		private readonly byte[] buf = new byte[1024];
		private int len, ptr;
		public bool isEof = false;
		public bool IsEndOfStream { get { return isEof; } }

		private byte read() {
			if (isEof) return 0;
			if (ptr >= len) {
				ptr = 0;
				if ((len = str.Read(buf, 0, 1024)) <= 0) {
					isEof = true;
					return 0;
				}
			}
			return buf[ptr++];
		}

		public char Char() {
			byte b = 0;
			do b = read(); while ((b < 33 || 126 < b) && !isEof);
			return (char)b;
		}
		public string Scan() {
			var sb = new StringBuilder();
			for (var b = Char(); b >= 33 && b <= 126; b = (char)read()) sb.Append(b);
			return sb.ToString();
		}
		public string ScanLine() {
			var sb = new StringBuilder();
			for (var b = Char(); b != '\n' && b != 0; b = (char)read()) if (b != '\r') sb.Append(b);
			return sb.ToString();
		}
		public long Long() { return isEof ? long.MinValue : long.Parse(Scan()); }
		public int Integer() { return isEof ? int.MinValue : int.Parse(Scan()); }
		public double Double() { return isEof ? double.NaN : double.Parse(Scan(), CultureInfo.InvariantCulture); }
	}
}

#endregion


using System;
using System.Linq;
using System.Collections.Generic;
using System.Diagnostics;
using Debug = System.Diagnostics.Trace;
using SB = System.Text.StringBuilder;
using System.Numerics;
using static System.Math;
using Number = System.Int64;
using N = System.Int64;
using C = System.Int32;
namespace Program {
	public class Solver {
		Random rnd = new Random();
		public void Solve() {
			var n = ri;
			var k = ri;
			var m = ri;
			var a = Enumerate(n, x => rl).OrderByDescending(x => x).ToArray();
			var s = 0L;
			var ans = -1.0;
			Debug.WriteLine(a.AsJoinedString());
			for (int i = 0; i < n; i++) {
				s += a[i];
				var rem = m - i - 1;
				if (rem < 0) continue;
				var v = s;
				v += Min(rem, k * (i + 1L));
				Debug.WriteLine($"{v} {v * 1.0 / (i + 1)}");
				ans = Max(ans, v * 1.0 / (i + 1));
			}
			Console.WriteLine(ans);
		}
		const long INF = 1L << 60;
		static int[] dx = { -1, 0, 1, 0 };
		static int[] dy = { 0, 1, 0, -1 };
		int ri { get { return sc.Integer(); } }
		long rl { get { return sc.Long(); } }
		double rd { get { return sc.Double(); } }
		string rs { get { return sc.Scan(); } }
		public IO.StreamScanner sc = new IO.StreamScanner(Console.OpenStandardInput());

		static T[] Enumerate<T>(int n, Func<int, T> f) {
			var a = new T[n];
			for (int i = 0; i < a.Length; ++i) a[i] = f(i);
			return a;
		}
		static public void Swap<T>(ref T a, ref T b) { var tmp = a; a = b; b = tmp; }
	}
}

#region main
static class Ex {
	static public string AsString(this IEnumerable<char> ie) { return new string(ie.ToArray()); }
	static public string AsJoinedString<T>(this IEnumerable<T> ie, string st = " ") {
		return string.Join(st, ie);
	}
	static public void Main() {
		//Console.SetOut(new Program.IO.Printer(Console.OpenStandardOutput()) { AutoFlush = false });
		var solver = new Program.Solver();
		solver.Solve();
		Console.Out.Flush();
	}
}
#endregion
#region Ex
namespace Program.IO {
	using System.IO;
	using System.Text;
	using System.Globalization;

	public class Printer : StreamWriter {
		public override IFormatProvider FormatProvider { get { return CultureInfo.InvariantCulture; } }
		public Printer(Stream stream) : base(stream, new UTF8Encoding(false, true)) { }
	}

	public class StreamScanner {
		public StreamScanner(Stream stream) { str = stream; }

		public readonly Stream str;
		private readonly byte[] buf = new byte[1024];
		private int len, ptr;
		public bool isEof = false;
		public bool IsEndOfStream { get { return isEof; } }

		private byte read() {
			if (isEof) return 0;
			if (ptr >= len) {
				ptr = 0;
				if ((len = str.Read(buf, 0, 1024)) <= 0) {
					isEof = true;
					return 0;
				}
			}
			return buf[ptr++];
		}

		public char Char() {
			byte b = 0;
			do b = read(); while ((b < 33 || 126 < b) && !isEof);
			return (char)b;
		}
		public string Scan() {
			var sb = new StringBuilder();
			for (var b = Char(); b >= 33 && b <= 126; b = (char)read()) sb.Append(b);
			return sb.ToString();
		}
		public string ScanLine() {
			var sb = new StringBuilder();
			for (var b = Char(); b != '\n' && b != 0; b = (char)read()) if (b != '\r') sb.Append(b);
			return sb.ToString();
		}
		public long Long() { return isEof ? long.MinValue : long.Parse(Scan()); }
		public int Integer() { return isEof ? int.MinValue : int.Parse(Scan()); }
		public double Double() { return isEof ? double.NaN : double.Parse(Scan(), CultureInfo.InvariantCulture); }
	}
}

#endregion


using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.IO;

namespace CodeForcesContest
{
    class Program
    {
        public static String[] Tokenizer;
        public static Stream InputStream;
        public static BufferedStream IBStream;
        public static StreamReader Scanner;

        static void Main(string[] args)
        {
            InputStream = Console.OpenStandardInput();
            IBStream = new BufferedStream(InputStream);
            Scanner = new StreamReader(IBStream);

            Tokenizer = Scanner.ReadLine().Split();
            int n = int.Parse(Tokenizer[0]);
			int k = int.Parse(Tokenizer[1]);
			int m = int.Parse(Tokenizer[2]);

            Tokenizer = Scanner.ReadLine().Split();
            double sum = 0;
			double bestResult = 0;
			int[] numbers = new int[n];

            for (int i = 0; i < n; ++i)
			{
                numbers[i] = int.Parse(Tokenizer[i]);
				sum += numbers[i];
			}

			bestResult = (sum + Math.Min(n * k * 1.0, m * 1.0)) / (1.0 * n);

            Array.Sort(numbers);
			/*
			for(int i = 0; i < n - 1; ++i)
			{
				int nn = (n-i-1);
				sum = sum - numbers[i];
				double getAll = Math.Min(1.0 * (n-i-1) * k,1.0 * m);
				bestResult = Math.Max(bestResult, (sum + getAll) / nn);
			}
			*/

			Console.WriteLine(numbers[numbers.Length - 1] + Math.Min(k,m));
			//Console.WriteLine(String.Format("{0:G17}", bestResult));
            return;
        }
    }
}


using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.IO;

namespace CodeForcesContest
{
    class Program
    {
        public static String[] Tokenizer;
        public static Stream InputStream;
        public static BufferedStream IBStream;
        public static StreamReader Scanner;

        static void Main(string[] args)
        {
            InputStream = Console.OpenStandardInput();
            IBStream = new BufferedStream(InputStream);
            Scanner = new StreamReader(IBStream);

            Tokenizer = Scanner.ReadLine().Split();
            int n = int.Parse(Tokenizer[0]);
			int k = int.Parse(Tokenizer[1]);
			int m = int.Parse(Tokenizer[2]);

            Tokenizer = Scanner.ReadLine().Split();
            double sum = 0;
			double bestResult = 0;
			int[] numbers = new int[n];

            for (int i = 0; i < n; ++i)
			{
                numbers[i] = int.Parse(Tokenizer[i]);
				sum += numbers[i];
			}

			bestResult = (sum + Math.Min(n * k * 1.0, m * 1.0)) / (1.0 * n);

            Array.Sort(numbers);

			for(int i = 0; i < n - 1 && m > 0; ++i)
			{
			    --m;
				int nn = (n-i-1);
				sum = sum - numbers[i];
				double getAll = Math.Min(1.0 * (n-i-1) * k,1.0 * m);
				bestResult = Math.Max(bestResult, (sum + getAll) / nn);
			}

		    Console.WriteLine(String.Format("{0:G17}", bestResult));

            return;
        }
    }
}


using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.IO;

namespace CodeForcesContest
{
    class Program
    {
        public static String[] Tokenizer;
        public static Stream InputStream;
        public static BufferedStream IBStream;
        public static StreamReader Scanner;

        static void Main(string[] args)
        {
            InputStream = Console.OpenStandardInput();
            IBStream = new BufferedStream(InputStream);
            Scanner = new StreamReader(IBStream);

            Tokenizer = Scanner.ReadLine().Split();
            int n = int.Parse(Tokenizer[0]);
			int k = int.Parse(Tokenizer[1]);
			int m = int.Parse(Tokenizer[2]);

            Tokenizer = Scanner.ReadLine().Split();
            double sum = 0;
			double bestResult = 0;
			int[] numbers = new int[n];

            for (int i = 0; i < n; ++i)
			{
                numbers[i] = int.Parse(Tokenizer[i]);
				sum += numbers[i];
			}

			bestResult = (sum + Math.Min(n * k, m)) / (1.0 * n);

            Array.Sort(numbers);

			for(int i = 0; i < n - 1; ++i)
			{
				int nn = (n-i-1);
				sum = sum - numbers[i];
				double getAll = Math.Min((n-i-1) * k * 1.0, m * 1.0);
				bestResult = Math.Max(bestResult, (sum + getAll) / nn);
			}

			Console.WriteLine(bestResult);
            return;
        }
    }
}


using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace b
{
    class Program
    {
        public static List<decimal> Heroes = new List<decimal>();
        public static int N,K,M;

        public static void Main()
        {
            // ParseInput(File.OpenText("test"));
            ParseInput(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding));
            Console.WriteLine(Answer());
        }

        public static void ParseInput(StreamReader input)
        {
            var line = input.ReadLine().Split(' ');
            N = int.Parse(line[0]);
            K = int.Parse(line[1]);
            M = int.Parse(line[2]);

            line = input.ReadLine().Split(' ');
            for(int i = 0; i < N; ++i)
            {
                Heroes.Add(int.Parse(line[i]));
            }
        }

        public static decimal Answer()
        {
            Heroes.Sort();

            int m = 0;
            int right = N -1;

            while(right >= 0 && (M - m) > N)
            {
                int numAdd = Math.Min(K-1, M - m - N);
                m += numAdd;
                Heroes[right] += numAdd;
                right--;
            }

            var avg = Heroes.Average();
            int rem = N;
            right = N-1;
            for(var i = 0; i < Math.Min(N, M - m); ++i)
            {
                if(rem >= 2)
                {
                    if(((avg * rem - Heroes[i]) / (rem-1)) - avg >= (decimal)1 / rem)
                    {
                        avg = (avg * rem - Heroes[i]) / (rem-1);
                        rem--;
                        continue;
                    }
                }

                avg += (decimal)1 / rem;
                Heroes[right] += 1;
                right--;
            }

            return avg;
        }
    }
}


using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

public class B
{
    public static List<int> heroes = new List<int>();
    public static int n,k,m;

    public static void Main()
    {
        // ParseInput(File.OpenText("test"));
        ParseInput(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding));
        var ans = Answer(heroes,k,m);
        Console.WriteLine(ans);
    }

    public static void ParseInput(StreamReader input)
    {
        var line = input.ReadLine().Split(' ');
        n = int.Parse(line[0]);
        k = int.Parse(line[1]);
        m = int.Parse(line[2]);

        line = input.ReadLine().Split(' ');
        for(int i = 0; i < n; ++i)
        {
            heroes.Add(int.Parse(line[i]));
        }
    }

    public static decimal Answer(List<int> heroes, int k, int m)
    {
        heroes.Sort();

        int n = heroes.Count();
        var avg = Average(heroes);
        int kk = 0, mm = 0;
        int left = 0, right = n-1;

        while(left <= right &&  mm <= m)
        {
            var rem = n - left;
            var min = heroes[left];

            if(rem >= 2)
            {
                var diff = ((avg * rem - min) / (rem - 1)) - avg;
                if(diff >= 1 / rem)
                {
                    left++;
                    avg += diff;
                    continue;
                }
            }

            avg += (decimal)1/rem;
            if(++kk == k)
            {
                right--;
                kk = 0;
            }

            mm++;
        }

        return avg;
    }

    public static decimal Average(List<int> heroes)
    {
        decimal average = 0;
        foreach(var hero in heroes) average += hero;
        return average / heroes.Count();
    }

}


using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace b
{
    class Program
    {
        public static List<decimal> Heroes = new List<decimal>();
        public static int N,K,M;

        public static void Main()
        {
            // ParseInput(File.OpenText("test"));
            ParseInput(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding));
            Console.WriteLine(Answer());
        }

        public static void ParseInput(StreamReader input)
        {
            var line = input.ReadLine().Split(' ');
            N = int.Parse(line[0]);
            K = int.Parse(line[1]);
            M = int.Parse(line[2]);

            line = input.ReadLine().Split(' ');
            for(int i = 0; i < N; ++i)
            {
                Heroes.Add(int.Parse(line[i]));
            }
        }

        public static decimal Answer()
        {
            Heroes.Sort();

            int m = 0;
            int right = N -1;

            while(right >= 0 && (M - m) > N)
            {
                int numAdd = Math.Min(K-1, M - m - N);
                m += numAdd;
                Heroes[right] += numAdd;
                right--;
            }

            var avg = Heroes.Average();
            int rem = N;
            int left = 0;
            right = N-1;
            for(var i = 0; i < Math.Min(N, M - m); ++i)
            {
                if(rem >= 2)
                {
                    var diff = ((avg * rem - Heroes[left]) / (rem - 1)) - avg;
                    if( diff > (decimal)1 / rem)
                    {
                        avg += diff;
                        rem--;
                        left++;
                        continue;
                    }
                }

                avg += (decimal)1 / rem;
                Heroes[right] += 1;
                right--;
            }

            return avg;
        }
    }
}


using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

public class B
{
    public static List<int> heroes = new List<int>();
    public static int n,k,m;

    public static void Main()
    {
        // ParseInput(File.OpenText("test"));
        ParseInput(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding));
        var ans = Answer(heroes,k,m);
        Console.WriteLine(ans);
    }

    public static void ParseInput(StreamReader input)
    {
        var line = input.ReadLine().Split(' ');
        n = int.Parse(line[0]);
        k = int.Parse(line[1]);
        m = int.Parse(line[2]);

        line = input.ReadLine().Split(' ');
        for(int i = 0; i < n; ++i)
        {
            heroes.Add(int.Parse(line[i]));
        }
    }

    public static decimal Answer(List<int> heroes, int k, int m)
    {
        heroes.Sort();

        int n = heroes.Count();
        var avg = Average(heroes);
        int kk = 0, mm = 0;
        int left = 0, right = n-1;

        while(left <= right && mm < m)
        {
            var rem = n - left;
            var min = heroes[left];

            if((rem-1) <= (m - mm) && rem >= 2)
            {
                var diff = ((avg * rem - min) / (rem - 1)) - avg;
                if(diff >= 1 / rem)
                {
                    left++;
                    avg += diff;
                    continue;
                }
            }

            avg += (decimal)1/rem;
            if(++kk == k)
            {
                right--;
                kk = 0;
            }

            mm++;
        }

        return avg;
    }

    public static decimal Average(List<int> heroes)
    {
        decimal average = 0;
        foreach(var hero in heroes) average += hero;
        return average / heroes.Count();
    }

}


using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace b
{
    class Program
    {
        public static List<int> Heroes = new List<int>();
        public static int N,K,M;

        public static void Main()
        {
            // ParseInput(File.OpenText("test"));
            ParseInput(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding));
            Console.WriteLine(Answer());
        }

        public static void ParseInput(StreamReader input)
        {
            var line = input.ReadLine().Split(' ');
            N = int.Parse(line[0]);
            K = int.Parse(line[1]);
            M = int.Parse(line[2]);

            line = input.ReadLine().Split(' ');
            for(int i = 0; i < N; ++i)
            {
                Heroes.Add(int.Parse(line[i]));
            }
        }

        public static decimal Answer()
        {
            Heroes.Sort();

            int m = 0;
            int right = N -1;

            while(right >= 0 && (M - m) > N)
            {
                int numAdd = Math.Min(K-1, M - m - N);
                m += numAdd;
                Heroes[right] += numAdd;
                right--;
            }

            var avg = (decimal)Heroes.Average();
            int rem = N;
            for(var i = 0; i < Math.Min(N, M - m); ++i)
            {
                if(rem >= 2)
                {
                    var diff = ((avg * rem - Heroes[i]) / (rem - 1)) - avg;
                    if(diff > (decimal)1 / rem)
                    {
                        avg += diff;
                        rem--;
                        continue;
                    }
                }

                avg += (decimal)1 / rem;
            }

            return avg;
        }
    }
}


using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

public class B
{
    public static List<int> heroes = new List<int>();
    public static int n,k,m;

    public static void Main()
    {
        // ParseInput(File.OpenText("test"));
        ParseInput(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding));
        var ans = Answer(heroes,k,m);
        Console.WriteLine(ans);
    }

    public static void ParseInput(StreamReader input)
    {
        var line = input.ReadLine().Split(' ');
        n = int.Parse(line[0]);
        k = int.Parse(line[1]);
        m = int.Parse(line[2]);

        line = input.ReadLine().Split(' ');
        for(int i = 0; i < n; ++i)
        {
            heroes.Add(int.Parse(line[i]));
        }
    }

    public static decimal Answer(List<int> heroes, int k, int m)
    {
        heroes.Sort();

        int n = heroes.Count();
        var avg = Average(heroes);
        int kk = 0, mm = 0;
        int left = 0, right = n-1;

        while(left <= right &&  mm < m)
        {
            var rem = n - left;
            var min = heroes[left];

            if(rem >= 2)
            {
                var diff = ((avg * rem - min) / (rem - 1)) - avg;
                if(diff >= 1 / rem)
                {
                    left++;
                    mm++;
                    avg += diff;
                    continue;
                }
            }

            avg += (decimal)1/rem;
            if(++kk == k)
            {
                right--;
                mm++;
                kk = 0;
            }
        }

        return avg;
    }

    public static decimal Average(List<int> heroes)
    {
        decimal average = 0;
        foreach(var hero in heroes) average += hero;
        return average / heroes.Count();
    }

}


using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace b
{
    class Program
    {
        public static List<int> Heroes = new List<int>();
        public static int N,K,M;

        public static void Main()
        {
            // ParseInput(File.OpenText("test"));
            ParseInput(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding));
            Console.WriteLine(Answer());
        }

        public static void ParseInput(StreamReader input)
        {
            var line = input.ReadLine().Split(' ');
            N = int.Parse(line[0]);
            K = int.Parse(line[1]);
            M = int.Parse(line[2]);

            line = input.ReadLine().Split(' ');
            for(int i = 0; i < N; ++i)
            {
                Heroes.Add(int.Parse(line[i]));
            }
        }

        public static decimal Answer()
        {
            Heroes.Sort();
            var avg = (decimal)Heroes.Average();

            int m = 0;
            int right = N -1;

            while(right >= 0 && (M - m) > N)
            {
                int numAdd = Math.Min(K-1, M - m - N);
                avg += (decimal)1 / N * numAdd;
                m += numAdd;
                Heroes[right] += numAdd;
                right--;
            }

            int rem = N;
            for(var i = 0; i < Math.Min(N, M - m); ++i)
            {
                if(rem >= 2)
                {
                    var diff = ((avg * rem - Heroes[i]) / (rem - 1)) - avg;
                    if(diff > (decimal)1 / rem)
                    {
                        avg += diff;
                        rem--;
                        continue;
                    }
                }

                avg += (decimal)1 / rem;
            }

            return avg;
        }
    }
}


using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace b
{
    class Program
    {
        public static List<decimal> Heroes = new List<decimal>();
        public static int N,K,M;

        public static void Main()
        {
            // ParseInput(File.OpenText("test"));
            ParseInput(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding));
            Console.WriteLine(Answer());
        }

        public static void ParseInput(StreamReader input)
        {
            var line = input.ReadLine().Split(' ');
            N = int.Parse(line[0]);
            K = int.Parse(line[1]);
            M = int.Parse(line[2]);

            line = input.ReadLine().Split(' ');
            for(int i = 0; i < N; ++i)
            {
                Heroes.Add(int.Parse(line[i]));
            }
        }

        public static decimal Answer()
        {
            Heroes.Sort();

            int m = 0;
            int right = N -1;

            while(right >= 0 && (M - m) > N)
            {
                int numAdd = Math.Min(K-1, M - m - N);
                m += numAdd;
                Heroes[right] += numAdd;
                right--;
            }

            var sum = Heroes.Sum();
            int rem = Math.Min(N, M - m);
            var best = (sum + rem) / N;
            for(var i = 0; i < rem; ++i)
            {
                if(i == N-1) break;
                sum -= Heroes[i];
                var amt = (sum + rem - i -1) / (N - i - 1);
                if(amt > best) best = amt;
            }

            return best;
        }
    }
}


using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace b
{
    class Program
    {
        public static List<decimal> Heroes = new List<decimal>();
        public static int N,K,M;

        public static void Main()
        {
            // ParseInput(File.OpenText("test"));
            ParseInput(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding));
            Console.WriteLine(Answer());
        }

        public static void ParseInput(StreamReader input)
        {
            var line = input.ReadLine().Split(' ');
            N = int.Parse(line[0]);
            K = int.Parse(line[1]);
            M = int.Parse(line[2]);

            line = input.ReadLine().Split(' ');
            for(int i = 0; i < N; ++i)
            {
                Heroes.Add(int.Parse(line[i]));
            }
        }

        public static decimal Answer()
        {
            Heroes.Sort();

            int m = 0;
            int right = N -1;

            while(right >= 0 && (M - m) > N)
            {
                int numAdd = Math.Min(K-1, M - m - N);
                m += numAdd;
                Heroes[right] += numAdd;
                right--;
            }

            var avg = Heroes.Average();
            int rem = N;
            int left = 0;
            for(var i = 0; i < Math.Min(N, M - m); ++i)
            {
                if(rem >= 2)
                {
                   if(Heroes[i] <= avg)
                    {
                        left++;
                        avg = Heroes.Skip(left).Average();
                    }
                }
            }

            return avg;
        }
    }
}


using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace b
{
    class Program
    {
        public static List<int> Heroes = new List<int>();
        public static int N,K,M;

        public static void Main()
        {
            // ParseInput(File.OpenText("test"));
            ParseInput(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding));
            Console.WriteLine(Answer());
        }

        public static void ParseInput(StreamReader input)
        {
            var line = input.ReadLine().Split(' ');
            N = int.Parse(line[0]);
            K = int.Parse(line[1]);
            M = int.Parse(line[2]);

            line = input.ReadLine().Split(' ');
            for(int i = 0; i < N; ++i)
            {
                Heroes.Add(int.Parse(line[i]));
            }
        }

        public static decimal Answer()
        {
            Heroes.Sort();
            var avg = (decimal)Heroes.Average();

            int m = 0;
            int right = N -1;

            while(right >= 0 && (M - m) > N)
            {
                int numAdd = Math.Min(K-1, M - m - N);
                avg += (decimal)1 / (N * numAdd);
                m += numAdd;
                Heroes[right] += numAdd;
                right--;
            }

            int rem = N;
            for(var i = 0; i < Math.Min(N, M - m); ++i)
            {
                if(rem >= 2)
                {
                    var diff = ((avg * rem - Heroes[i]) / (rem - 1)) - avg;
                    if(diff > (decimal)1 / rem)
                    {
                        avg += diff;
                        rem--;
                        continue;
                    }
                }

                avg += (decimal)1 / rem;
            }

            return avg;
        }
    }
}


using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace b
{
    class Program
    {
        public static List<decimal> Heroes = new List<decimal>();
        public static int N,K,M;

        public static void Main()
        {
            // ParseInput(File.OpenText("test"));
            ParseInput(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding));
            Console.WriteLine(Answer());
        }

        public static void ParseInput(StreamReader input)
        {
            var line = input.ReadLine().Split(' ');
            N = int.Parse(line[0]);
            K = int.Parse(line[1]);
            M = int.Parse(line[2]);

            line = input.ReadLine().Split(' ');
            for(int i = 0; i < N; ++i)
            {
                Heroes.Add(int.Parse(line[i]));
            }
        }

        public static decimal Answer()
        {
            Heroes.Sort();

            int m = 0;
            int right = N -1;

            while(right >= 0 && (M - m) > N)
            {
                int numAdd = Math.Min(K-1, M - m - N);
                m += numAdd;
                Heroes[right] += numAdd;
                right--;
            }

            var avg = Heroes.Average();
            int rem = N;
            right = N-1;
            for(var i = 0; i < Math.Min(N, M - m); ++i)
            {
                if(rem >= 2)
                {
                    var diff = ((avg * rem - Heroes[i]) / (rem-1)) - avg;
                    if(diff >= (decimal)1 / rem)
                    {
                        avg += diff;
                        rem--;
                        continue;
                    }
                }

                avg += (decimal)1 / rem;
                Heroes[right] += 1;
                right--;
            }

            return avg;
        }
    }
}


using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System.Diagnostics;

public class B
{
    public static List<int> heroes = new List<int>();
    public static int n,k,m;

    public static void Main()
    {
        // ParseInput(File.OpenText("test"));
        ParseInput(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding));
        var ans = Answer(heroes,k,m);
        Console.WriteLine(ans);
    }

    public static void ParseInput(StreamReader input)
    {
        var line = input.ReadLine().Split(' ');
        n = int.Parse(line[0]);
        k = int.Parse(line[1]);
        m = int.Parse(line[2]);

        line = input.ReadLine().Split(' ');
        for(int i = 0; i < n; ++i)
        {
            heroes.Add(int.Parse(line[i]));
        }
    }

    public static decimal Answer(List<int> heroes, int k, int m)
    {
        heroes.Sort();

        int n = heroes.Count();
        var avg = Average(heroes);
        int kk = 0, mm = 0;
        int left = 0, right = n-1;

        while(left <= right &&  mm < m)
        {
            var rem = n - left;
            var min = heroes[left];

            if(rem >= 2)
            {
                var diff = ((avg * rem - min) / (rem - 1)) - avg;
                if(diff >= 1 / rem)
                {
                    left++;
                    mm++;
                    avg += diff;
                    continue;
                }
            }

            avg += 1/rem;
            if(++kk == k)
            {
                right--;
                mm++;
                kk = 0;
            }
        }

        return avg;
    }

    public static decimal Average(List<int> heroes)
    {
        decimal average = 0;
        foreach(var hero in heroes) average += hero;
        return average / heroes.Count();
    }

}


using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace b
{
    class Program
    {
        public static List<decimal> Heroes = new List<decimal>();
        public static int N,K,M;

        public static void Main()
        {
            // ParseInput(File.OpenText("test"));
            ParseInput(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding));
            Console.WriteLine(Answer());
        }

        public static void ParseInput(StreamReader input)
        {
            var line = input.ReadLine().Split(' ');
            N = int.Parse(line[0]);
            K = int.Parse(line[1]);
            M = int.Parse(line[2]);

            line = input.ReadLine().Split(' ');
            for(int i = 0; i < N; ++i)
            {
                Heroes.Add(int.Parse(line[i]));
            }
        }

        public static decimal Answer()
        {
            Heroes.Sort();

            int m = 0;
            int right = N -1;

            while(right >= 0 && (M - m) > N)
            {
                int numAdd = Math.Min(K-1, M - m - N);
                m += numAdd;
                Heroes[right] += numAdd;
                right--;
            }

            var avg = Heroes.Average();
            int rem = N;
            int left = 0;
            right = N-1;
            for(var i = 0; i < Math.Min(N, M - m); ++i)
            {
                if(rem >= 2)
                {
                    if(((avg * rem - Heroes[left]) / (rem-1)) - avg >= (decimal)1 / rem)
                    {
                        avg = (avg * rem - Heroes[i]) / (rem - 1);
                        rem--;
                        left++;
                        continue;
                    }
                }

                avg += (decimal)1 / rem;
                Heroes[right] += 1;
                right--;
            }

            return avg;
        }
    }
}


using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace b
{
    class Program
    {
        public static List<decimal> Heroes = new List<decimal>();
        public static int N,K,M;

        public static void Main()
        {
            // ParseInput(File.OpenText("test"));
            ParseInput(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding));
            Console.WriteLine(Answer());
        }

        public static void ParseInput(StreamReader input)
        {
            var line = input.ReadLine().Split(' ');
            N = int.Parse(line[0]);
            K = int.Parse(line[1]);
            M = int.Parse(line[2]);

            line = input.ReadLine().Split(' ');
            for(int i = 0; i < N; ++i)
            {
                Heroes.Add(int.Parse(line[i]));
            }
        }

        public static decimal Answer()
        {
            Heroes.Sort();

            int m = 0;
            int right = N -1;

            while(right >= 0 && (M - m) > N)
            {
                int numAdd = Math.Min(K-1, M - m - N);
                m += numAdd;
                Heroes[right] += numAdd;
                right--;
            }

            var avg = Heroes.Average();
            int rem = N;
            for(var i = 0; i < Math.Min(N, M - m); ++i)
            {
                if(rem >= 2)
                {
                    var diff = ((avg * rem - Heroes[i]) / (rem - 1)) - avg;
                    if(diff > (decimal)1 / rem)
                    {
                        avg += diff;
                        rem--;
                        continue;
                    }
                }

                avg += (decimal)1 / rem;
            }

            return avg;
        }
    }
}


using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace b
{
    class Program
    {
        public static List<decimal> Heroes = new List<decimal>();
        public static int N,K,M;

        public static void Main()
        {
            // ParseInput(File.OpenText("test"));
            ParseInput(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding));
            Console.WriteLine(Answer());
        }

        public static void ParseInput(StreamReader input)
        {
            var line = input.ReadLine().Split(' ');
            N = int.Parse(line[0]);
            K = int.Parse(line[1]);
            M = int.Parse(line[2]);

            line = input.ReadLine().Split(' ');
            for(int i = 0; i < N; ++i)
            {
                Heroes.Add(int.Parse(line[i]));
            }
        }

        public static decimal Answer()
        {
            Heroes.Sort();

            int m = 0;
            int right = N -1;

            while(right >= 0 && (M - m) > N)
            {
                int numAdd = Math.Min(K-1, M - m - N);
                m += numAdd;
                Heroes[right] += numAdd;
                right--;
            }

            var avg = Heroes.Average();
            int rem = N;
            right = N-1;
            for(var i = 0; i < Math.Min(N, M - m); ++i)
            {
                if(rem >= 2)
                {
                   if(Heroes[i] <= avg)
                    {
                        avg = (avg * rem - Heroes[i]) / (rem -1);
                        rem--;
                        continue;
                    }
                }

                avg += (decimal)1 / rem;
                Heroes[right] += 1;
                right--;
            }

            return avg;
        }
    }
}


using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace b
{
    class Program
    {
        public static List<int> Heroes = new List<int>();
        public static int N,K,M;

        public static void Main()
        {
            // ParseInput(File.OpenText("test"));
            ParseInput(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding));
            Console.WriteLine(Answer());
        }

        public static void ParseInput(StreamReader input)
        {
            var line = input.ReadLine().Split(' ');
            N = int.Parse(line[0]);
            K = int.Parse(line[1]);
            M = int.Parse(line[2]);

            line = input.ReadLine().Split(' ');
            for(int i = 0; i < N; ++i)
            {
                Heroes.Add(int.Parse(line[i]));
            }
        }

        public static double Answer()
        {
            Heroes.Sort();
            var avg = Heroes.Average();

            int m = 0;
            int right = N -1;

            while(right >= 0 && (M - m) > N)
            {
                int numAdd = Math.Min(K-1, M - m - N);
                avg += (double)1 / N * numAdd;
                m += numAdd;
                Heroes[right] += numAdd;
                right--;
            }

            int rem = N;
            for(var i = 0; i < Math.Min(N, M - m); ++i)
            {
                if(rem >= 2)
                {
                    var diff = ((avg * rem - Heroes[i]) / (rem - 1)) - avg;
                    if(diff > (double)1 / rem)
                    {
                        avg += diff;
                        rem--;
                        continue;
                    }
                }

                avg += (double)1 / rem;
            }

            return avg;
        }
    }
}


using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace b
{
    class Program
    {
        public static List<decimal> Heroes = new List<decimal>();
        public static int N,K,M;

        public static void Main()
        {
            // ParseInput(File.OpenText("test"));
            ParseInput(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding));
            Console.WriteLine(Answer());
        }

        public static void ParseInput(StreamReader input)
        {
            var line = input.ReadLine().Split(' ');
            N = int.Parse(line[0]);
            K = int.Parse(line[1]);
            M = int.Parse(line[2]);

            line = input.ReadLine().Split(' ');
            for(int i = 0; i < N; ++i)
            {
                Heroes.Add(int.Parse(line[i]));
            }
        }

        public static decimal Answer()
        {
            Heroes.Sort();

            int m = 0;
            int right = N -1;

            while(right >= 0 && (M - m) > N)
            {
                int numAdd = Math.Min(K-1, M - m - N);
                m += numAdd;
                Heroes[right] += numAdd;
                right--;
            }

            var avg = Heroes.Average();
            int rem = N;
            int left = 0;
            right = N-1;
            for(var i = 0; i < Math.Min(N, M - m); ++i)
            {
                if(rem >= 2)
                {
                    if(((avg * rem - Heroes[left]) / (rem-1)) - avg >= (decimal)1 / rem)
                    {
                        avg = (avg * rem - Heroes[left]) / (rem - 1);
                        rem--;
                        left++;
                        continue;
                    }
                }

                avg += (decimal)1 / rem;
                Heroes[right] += 1;
                right--;
            }

            return avg;
        }
    }
}


using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace b
{
    class Program
    {
        public static List<int> Heroes = new List<int>();
        public static int N,K,M;

        public static void Main()
        {
            // ParseInput(File.OpenText("test"));
            ParseInput(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding));
            Console.WriteLine(Answer());
        }

        public static void ParseInput(StreamReader input)
        {
            var line = input.ReadLine().Split(' ');
            N = int.Parse(line[0]);
            K = int.Parse(line[1]);
            M = int.Parse(line[2]);

            line = input.ReadLine().Split(' ');
            for(int i = 0; i < N; ++i)
            {
                Heroes.Add(int.Parse(line[i]));
            }
        }

        public static double Answer()
        {
            Heroes.Sort();
            var avg = Heroes.Average();

            int m = 0;
            int right = N -1;

            while(right >= 0 && (M - m) > N)
            {
                int numAdd = Math.Min(K-1, M - m - N);
                avg += (double)1 / N * numAdd;
                m += numAdd;
                Heroes[right] += numAdd;
                right--;
            }

            int rem = N;
            for(var i = 0; i < N; ++i)
            {
                if(rem >= 2)
                {
                    var diff = ((avg * rem - Heroes[i]) / (rem - 1)) - avg;
                    if(diff > (double)1 / rem)
                    {
                        avg += diff;
                        rem--;
                        continue;
                    }
                }

                avg += (double)1 / rem;
            }

            return avg;
        }
    }
}


using System;
using System.Collections.Generic;
class Program
{
	static void Main(string[] args)
	{
		string[] str = Console.ReadLine().Split();
		int N = int.Parse(str[0]);
		int K = int.Parse(str[1]);
		int M = int.Parse(str[2]);
		string[] str2 = Console.ReadLine().Split();
		int[]A = new int[N];
		long sum = 0;
		for(var i=0;i<N;i++){
			A[i] = int.Parse(str2[i]);
			sum += A[i];
		}
		Array.Sort(A);
		double max = 0;
		for(var i=0;i<Math.Min(M+1,N);i++){
			int ct = Math.Max(0,Math.Min(K*(N-i),M-i));
			double ans = (sum+ct) / (double)(N-i);
			max = Math.Max(max,ans);
			sum -= A[i];
		}
		Console.WriteLine(max);
	}
}


using System;
using System.Collections.Generic;
class Program
{
	static void Main(string[] args)
	{
		string[] str = Console.ReadLine().Split();
		int N = int.Parse(str[0]);
		int K = int.Parse(str[1]);
		int M = int.Parse(str[2]);
		string[] str2 = Console.ReadLine().Split();
		int[]A = new int[N];
		long sum = 0;
		for(var i=0;i<N;i++){
			A[i] = int.Parse(str2[i]);
			sum += A[i];
		}
		Array.Sort(A);
		int na = 0;
		int nb = N-1;
		int[]Kn = new int[N];
		while(M>0){
			if(na < N-1 && (sum-A[na])/(double)(N-na-1) >= (sum+1)/(double)(N-na)){
				sum-=A[na];
				na++;
				M--;
			} else {
				if(Kn[nb]==K){
					nb--;
					if(na>nb){
						break;
					}
				}
				Kn[nb]++;
				sum++;
				M--;
			}
		}
		Console.WriteLine(sum/(double)(N-na));
	}
}


using System;
using System.Collections.Generic;
class Program
{
	static void Main(string[] args)
	{
		string[] str = Console.ReadLine().Split();
		int N = int.Parse(str[0]);
		int K = int.Parse(str[1]);
		int M = int.Parse(str[2]);
		string[] str2 = Console.ReadLine().Split();
		int[]A = new int[N];
		long sum = 0;
		for(var i=0;i<N;i++){
			A[i] = int.Parse(str2[i]);
			sum += A[i];
		}
		Array.Sort(A);
		double max = 0;
		for(var i=0;i<Math.Min(M,N);i++){
			int ct = Math.Max(0,Math.Min(K*(N-i),M-i));
			double ans = (sum+ct) / (double)(N-i);
			max = Math.Max(max,ans);
			sum -= A[i];
		}
		Console.WriteLine(max);
	}
}


using System;
using System.Collections.Generic;
class Program
{
	static void Main(string[] args)
	{
		string[] str = Console.ReadLine().Split();
		int N = int.Parse(str[0]);
		int K = int.Parse(str[1]);
		int M = int.Parse(str[2]);
		string[] str2 = Console.ReadLine().Split();
		int[]A = new int[N];
		long sum = 0;
		for(var i=0;i<N;i++){
			A[i] = int.Parse(str2[i]);
			sum += A[i];
		}
		Array.Sort(A);
		double max = 0;
		for(var i=0;i<N;i++){
			int ct = Math.Min(K*(N-i),M-i);
			double ans = (sum+ct) / (double)(N-i);
			max = Math.Max(max,ans);
			sum -= A[i];
		}
		Console.WriteLine(max);
	}
}


using System;
using System.Collections.Generic;
class Program
{
	static void Main(string[] args)
	{
		string[] str = Console.ReadLine().Split();
		int N = int.Parse(str[0]);
		int K = int.Parse(str[1]);
		int M = int.Parse(str[2]);
		string[] str2 = Console.ReadLine().Split();
		int[]A = new int[N];
		long sum = 0;
		for(var i=0;i<N;i++){
			A[i] = int.Parse(str2[i]);
			sum += A[i];
		}
		Array.Sort(A);
		double max = 0;
		for(var i=0;i<N;i++){
			int ct = Math.Max(0,Math.Min(K*(N-i),M-i));
			double ans = (sum+ct) / (double)(N-i);
			max = Math.Max(max,ans);
			sum -= A[i];
		}
		Console.WriteLine(max);
	}
}


using System;
using System.Globalization;
using System.IO;
using System.Text;

namespace Average_Superhero_Gang_Power
{
    internal class Program
    {
        private static readonly StreamReader reader = new StreamReader(Console.OpenStandardInput(1024*10), Encoding.ASCII, false, 1024*10);
        private static readonly StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(1024*10), Encoding.ASCII, 1024*10);

        private static void Main(string[] args)
        {
            writer.WriteLine(Solve(args).ToString("#0.00000000", CultureInfo.InvariantCulture));
            writer.Flush();
        }

        private static double Solve(string[] args)
        {
            int n = Next();
            long k = Next();
            int m = Next();

            var nn = new int[n];
            long sum = 0;
            for (int i = 0; i < n; i++)
            {
                nn[i] = Next();
                sum += nn[i];
            }

            double ans = 0;
            Array.Sort(nn);
            for (int i = 0; i < n && i <= m; i++)
            {
                ans = Math.Max(ans, 1.0*(sum + Math.Min(k*(n - i), m - i))/(n - i));
                sum -= nn[i];
            }

            return ans;
        }

        private static int Next()
        {
            int c;
            int res = 0;
            do
            {
                c = reader.Read();
                if (c == -1)
                    return res;
            } while (c < '0' || c > '9');
            res = c - '0';
            while (true)
            {
                c = reader.Read();
                if (c < '0' || c > '9')
                    return res;
                res *= 10;
                res += c - '0';
            }
        }
    }
}


using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;

public class Solver
{
    public void Solve()
    {
        string[] tokens = reader.ReadLine().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
        int n = int.Parse(tokens[0]);
        int k = int.Parse(tokens[1]);
        int m = int.Parse(tokens[2]);

        tokens = reader.ReadLine().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
        List<int> a = new List<int>(n);
        foreach (var token in tokens)
        {
            a.Add(int.Parse(token));
        }

        a.Sort();

        double avg = 0;
        if (m >= n)
        {
            int max = a[n - 1];
            m -= n - 1;
            max += Math.Min(m, k);
            avg = max;
        }
        else
        {
            ulong sum = 0;
            foreach (var x in a)
            {
                sum += (ulong)x;
            }

            avg = 1.0 * sum / (ulong)n;
            int n1 = n;
            int cur = 0;
            int capacity = 0;
            while (m > 0)
            {
                ulong sum1 = 0;
                ulong sum2 = 0;
                double avg1 = 0;
                double avg2 = 0;

                if (n1 > 1)
                {
                    sum1 = sum - (ulong)a[cur];
                    avg1 = 1.0 * sum1 / (n1 - 1);
                }

                if (capacity < k * n1)
                {
                    sum2 = sum + 1;
                    avg2 = 1.0 * sum2 / (ulong)n1;
                }

                if (sum1 == 0 && sum2 == 0)
                {
                    break;
                }
                if (avg1 < avg && avg2 < avg)
                {
                    break;
                }

                if (avg1 > avg2)
                {
                    cur++;
                    n1--;
                    m--;
                    sum = sum1;
                    avg = avg1;
                }
                else
                {
                    capacity++;
                    m--;
                    sum = sum2;
                    avg = avg2;
                }
            }
        }

        writer.WriteLine(avg);
    }

    static void Main()
    {
#if DEBUG
        reader = new StreamReader("..\\..\\input.txt");
        //reader = new StreamReader(Console.OpenStandardInput());
        writer = Console.Out;
        //writer = new StreamWriter("..\\..\\output.txt");
        Stopwatch watch = new Stopwatch();
        watch.Start();
#else
        reader = new StreamReader(Console.OpenStandardInput());
        writer = new StreamWriter(Console.OpenStandardOutput());
        //reader = new StreamReader("input.txt");
        //writer = new StreamWriter("output.txt");
#endif
        try
        {

            new Solver().Solve();
            //var thread = new Thread(new Solver().Solve, 1024 * 1024 * 128);
            //thread.Start();
            //thread.Join();

#if DEBUG
            watch.Stop();
            writer.WriteLine("Stopwatch: " + watch.ElapsedMilliseconds + "ms");
#endif
        }
        catch (Exception ex)
        {
#if DEBUG
            Console.WriteLine(ex);
#else
            throw;
#endif
        }
        reader.Close();
        writer.Close();
    }
    protected static TextReader reader;
    protected static TextWriter writer;
}


//#define EXTENDSTACKSIZE

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;

namespace CF
{
    internal class Program
    {
        private const int stackSize = 64 * 1024 * 1024;

        private static void Run()
        {
            using (var sr = new InputReader(Console.In))
//            using (var sr = new InputReader(new StreamReader("input.txt")))
            using (var sw = Console.Out)
//            using (var sw = new StreamWriter("output.txt"))
            using (var task = new Task(sr, sw)) {
                task.Solve();
//                Console.ReadKey();
            }
        }

        private static void Main(string[] args)
        {
#if EXTENDSTACKSIZE
            var threadStart = new ThreadStart(Run);
            var thread = new Thread(threadStart, stackSize);
            thread.Start();
            thread.Join();
#else
            Run();
#endif
        }
    }

    internal class Task : IDisposable
    {
        private readonly InputReader sr;
        private readonly TextWriter sw;
        private bool isDispose;

        public Task(InputReader sr, TextWriter sw)
        {
            this.sr = sr;
            this.sw = sw;
        }

        public void Solve()
        {
            var n = sr.NextInt32();
            var k = sr.NextInt32();
            var m = sr.NextInt32();
            var forces = sr.ReadArrayOfInt32();
            Array.Sort(forces, (a, b) => -a.CompareTo(b));
            var equalFirst = 0;
            for (var i = 1; i < forces.Length; i++)
            {
                if (forces[i] == forces[0])
                {
                    equalFirst++;
                }
                else
                {
                    break;
                }
            }

            var d = n - equalFirst - 1;
            if (d >= m)
            {
                var sum = 0L;
                var different = new List<Pair>();
                var curr = forces[equalFirst + 1];
                different.Add(new Pair { Value = curr, Count = 1 });
                for (var i = equalFirst + 2; i < n; i++) {
                    if (forces[i] == curr) {
                        different[different.Count - 1].Count++;
                    }
                    else {
                        curr = forces[i];
                        different.Add(new Pair { Value = curr, Count = 1 });
                    }
                }

                var index = different.Count - 1;
                var tmpM = m;
                for (var i = 0; i < tmpM; i++) {
                    if (index > 0) {
                        var last = different[index];
                        last.Count--;
                        if (last.Count == 0) {
                            index--;
                        }

                        m--;
                    }
                    else {
                        var last = different[index];
                        if (last.Count == 1) {
                            last.Count--;
                            m--;
                        }

                        break;
                    }
                }

                sum = (equalFirst + 1L) * forces[0];
                index = 0;
                var num = equalFirst + 1L;
                while (true) {
                    if (index == different.Count)
                        break;
                    if (m > 0) {
                        var last = different[index];
                        if (last.Count > 0) {
                            sum += last.Value + 1L;
                            last.Count--;
                            num++;
                        }

                        if (last.Count == 0) {
                            index++;
                        }

                        m--;
                    }
                    else {
                        var last = different[index];
                        if (last.Count > 0) {
                            sum += last.Value;
                            last.Count--;
                            num++;
                        }

                        if (last.Count == 0) {
                            index++;
                        }
                    }
                }

                var res = (double) sum / num;
                sw.WriteLine(res.ToString("F7"));
            }
            else
            {
                m -= d;
                var need = (equalFirst + 1L) * k;
                if (need <= m)
                {
                    var res = forces[0] + k;
                    sw.WriteLine(res);
                }
                else
                {
                    if (m > equalFirst)
                    {
                        m -= equalFirst;
                        var res = forces[0];
                        if (m >= k)
                        {
                            res += k;
                        }
                        else
                        {
                            res += m;
                        }

                        sw.WriteLine(res);
                    }
                    else
                    {
                        var res = (double) ((equalFirst + 1L) * forces[0] + m) / (equalFirst + 1.0);
                        sw.WriteLine(res.ToString("F7"));
                    }
                }
            }
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        private void Dispose(bool disposing)
        {
            if (!isDispose) {
                if (disposing) {
                    if(sr != null)
                        sr.Dispose();

                    if(sw != null)
                        sw.Dispose();
                }

                isDispose = true;
            }
        }
    }
}

class Pair
{
    public int Value { get; set; }

    public int Count { get; set; }
}

internal class InputReader : IDisposable
{
    private bool isDispose;
    private readonly TextReader sr;
    private string[] buffer;
    private int seek;

    public InputReader(TextReader stream)
    {
        sr = stream;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    public string NextString()
    {
        var result = sr.ReadLine();
        return result;
    }

    public int NextInt32()
    {
        return Int32.Parse(ReadNextToken());
    }

    private string ReadNextToken()
    {
        if (buffer == null || seek == buffer.Length) {
            seek = 0;
            buffer = NextSplitStrings();
        }

        return buffer[seek++];
    }

    public long NextInt64()
    {
        return Int64.Parse(ReadNextToken());
    }

    public int[] ReadArrayOfInt32()
    {
        return ReadArray(Int32.Parse);
    }

    public long[] ReadArrayOfInt64()
    {
        return ReadArray(Int64.Parse);
    }

    public string[] NextSplitStrings()
    {
        return NextString()
            .Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
    }

    public T[] ReadArray<T>(Func<string, CultureInfo, T> func)
    {
        return NextSplitStrings()
            .Select(s => func(s, CultureInfo.InvariantCulture))
            .ToArray();
    }

    public T[] ReadArrayFromString<T>(Func<string, CultureInfo, T> func, string str)
    {
        return
            str.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
                .Select(s => func(s, CultureInfo.InvariantCulture))
                .ToArray();
    }

    protected void Dispose(bool dispose)
    {
        if (!isDispose)
        {
            if (dispose)
                sr.Close();

            isDispose = true;
        }
    }

    ~InputReader()
    {
        Dispose(false);
    }
}


//#define EXTENDSTACKSIZE

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;

namespace CF
{
    internal class Program
    {
        private const int stackSize = 64 * 1024 * 1024;

        private static void Run()
        {
            using (var sr = new InputReader(Console.In))
//            using (var sr = new InputReader(new StreamReader("input.txt")))
            using (var sw = Console.Out)
//            using (var sw = new StreamWriter("output.txt"))
            using (var task = new Task(sr, sw)) {
                task.Solve();
//                Console.ReadKey();
            }
        }

        private static void Main(string[] args)
        {
#if EXTENDSTACKSIZE
            var threadStart = new ThreadStart(Run);
            var thread = new Thread(threadStart, stackSize);
            thread.Start();
            thread.Join();
#else
            Run();
#endif
        }
    }

    internal class Task : IDisposable
    {
        private readonly InputReader sr;
        private readonly TextWriter sw;
        private bool isDispose;

        public Task(InputReader sr, TextWriter sw)
        {
            this.sr = sr;
            this.sw = sw;
        }

        public void Solve()
        {
            var n = sr.NextInt32();
            var k = sr.NextInt32();
            var m = sr.NextInt32();
            var forces = sr.ReadArrayOfInt32();
            Array.Sort(forces, (a, b) => -a.CompareTo(b));
            var equalFirst = 0;
            for (var i = 1; i < forces.Length; i++)
            {
                if (forces[i] == forces[0])
                {
                    equalFirst++;
                }
                else
                {
                    break;
                }
            }

            var d = n - equalFirst - 1;
            if (d >= m)
            {
                var sum = 0L;
                var different = new List<Pair>();
                var curr = forces[equalFirst + 1];
                different.Add(new Pair { Value = curr, Count = 1 });
                for (var i = equalFirst + 2; i < n; i++) {
                    if (forces[i] == curr) {
                        different[different.Count - 1].Count++;
                    }
                    else {
                        curr = forces[i];
                        different.Add(new Pair { Value = curr, Count = 1 });
                    }
                }

                var index = different.Count - 1;
                var tmpM = m;
                for (var i = 0; i < tmpM; i++) {
                    if (index > 0) {
                        var last = different[index];
                        last.Count--;
                        if (last.Count == 0) {
                            index--;
                        }

                        m--;
                    }
                    else {
                        break;
                    }
                }

                sum = (equalFirst + 1L) * forces[0];
                index = 0;
                var num = equalFirst + 1L;
                while (true) {
                    if (index == different.Count)
                        break;
                    if (m > 0) {
                        var last = different[index];
                        if (last.Count > 0) {
                            sum += last.Value + 1L;
                            last.Count--;
                            num++;
                        }

                        if (last.Count == 0) {
                            index++;
                        }

                        m--;
                    }
                    else {
                        var last = different[index];
                        if (last.Count > 0) {
                            sum += last.Value;
                            last.Count--;
                            num++;
                        }

                        if (last.Count == 0) {
                            index++;
                        }
                    }
                }

                var res = (double) sum / num;
                sw.WriteLine(res.ToString("F7"));
            }
            else
            {
                m -= d;
                var need = (equalFirst + 1L) * k;
                if (need <= m)
                {
                    var res = forces[0] + k;
                    sw.WriteLine(res);
                }
                else
                {
                    if (m > equalFirst)
                    {
                        m -= equalFirst;
                        var res = forces[0];
                        if (m >= k)
                        {
                            res += k;
                        }
                        else
                        {
                            res += m;
                        }

                        sw.WriteLine(res);
                    }
                    else
                    {
                        var res = (double) ((equalFirst + 1) * forces[0] + m) / (equalFirst + 1.0);
                        sw.WriteLine(res.ToString("F7"));
                    }
                }
            }
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        private void Dispose(bool disposing)
        {
            if (!isDispose) {
                if (disposing) {
                    if(sr != null)
                        sr.Dispose();

                    if(sw != null)
                        sw.Dispose();
                }

                isDispose = true;
            }
        }
    }
}

class Pair
{
    public int Value { get; set; }

    public int Count { get; set; }
}

internal class InputReader : IDisposable
{
    private bool isDispose;
    private readonly TextReader sr;
    private string[] buffer;
    private int seek;

    public InputReader(TextReader stream)
    {
        sr = stream;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    public string NextString()
    {
        var result = sr.ReadLine();
        return result;
    }

    public int NextInt32()
    {
        return Int32.Parse(ReadNextToken());
    }

    private string ReadNextToken()
    {
        if (buffer == null || seek == buffer.Length) {
            seek = 0;
            buffer = NextSplitStrings();
        }

        return buffer[seek++];
    }

    public long NextInt64()
    {
        return Int64.Parse(ReadNextToken());
    }

    public int[] ReadArrayOfInt32()
    {
        return ReadArray(Int32.Parse);
    }

    public long[] ReadArrayOfInt64()
    {
        return ReadArray(Int64.Parse);
    }

    public string[] NextSplitStrings()
    {
        return NextString()
            .Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
    }

    public T[] ReadArray<T>(Func<string, CultureInfo, T> func)
    {
        return NextSplitStrings()
            .Select(s => func(s, CultureInfo.InvariantCulture))
            .ToArray();
    }

    public T[] ReadArrayFromString<T>(Func<string, CultureInfo, T> func, string str)
    {
        return
            str.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
                .Select(s => func(s, CultureInfo.InvariantCulture))
                .ToArray();
    }

    protected void Dispose(bool dispose)
    {
        if (!isDispose)
        {
            if (dispose)
                sr.Close();

            isDispose = true;
        }
    }

    ~InputReader()
    {
        Dispose(false);
    }
}