import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

import static java.lang.Math.abs;
import static java.lang.Math.max;
import static java.lang.Math.min;

public class Maarten {

    public static void main(String[] args) throws IOException {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
            new Maarten().run(new Scanner(reader));
        }
    }

    double[][] ps;
    int q;

    public void run(Scanner sc) throws IOException {
        int n = sc.nextInt(), k = sc.nextInt();
        double goal = sc.nextInt();
        double[] xs = new double[n];
        for (int i = 0; i < n; i++) {
            xs[i] = sc.nextInt();
        }

        double s = 0;
        for (double x : xs) s += x;
        double m = abs(goal - s / n);

        if (k >= 1)
            for (int i = 0; i < n; i++)
                m = min(m, abs(goal - (s - xs[i]) / (n - 1)));
        if (k >= 2)
            for (int i = 0; i < n; i++)
                for (int j = 0; j < i; j++)
                    m = min(m, abs(goal - (s - xs[i] - xs[j]) / (n - 2)));
        if (k >= 3) {
            ps = new double[n * (n - 1) / 2][3];
            for (int i = 0, p = 0; i < n; i++) {
                for (int j = 0; j < i; j++) {
                    ps[p][0] = xs[i] + xs[j];
                    ps[p][1] = i;
                    ps[p][2] = j;
                    p++;
                }
            }
            Arrays.sort(ps, Comparator.<double[]>comparingDouble(a -> a[0]).thenComparingDouble(a -> a[1]));
            q = ps.length - 1;
            for (int i = 0; i < n; i++)
                for (double p : find_pair(s - xs[i] - goal * (n - 3), new double[]{i}))
                    m = min(m, abs(goal - (s - xs[i] - p) / (n - 3)));
        }
        if (k >= 4)
            for (int i = 0; i < n; i++)
                for (int j = 0; j < i; j++)
                    for (double p : find_pair(s - xs[i] - xs[j] - goal * (n - 4), new double[]{i, j}))
                        m = min(m, abs(goal - (s - xs[i] - xs[j] - p) / (n - 4)));

        System.out.println(m);
    }

    double[] find_pair(double target, double[] used) {
        int i = Arrays.binarySearch(ps, new double[]{target}, Comparator.comparingDouble(a -> a[0]));
        if (i < 0) i = -i - 1;
        i = min(q, i);
        int l = i + 1 - max(0, i - 1);
        double[] res = new double[l];
        for (int j = max(0, i - 1), k = 0; j < i + 1; j++) {
            res[k] = ps[j][0];
            for (double u : used) {
                if (u == ps[j][1] || u == ps[j][2]) res[k] = 1e14;
            }
            k++;
        }
        return res;
    }
}