import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.io.InputStream;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.IOException;
import java.util.InputMismatchException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.OutputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Alex
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(1, in, out);
        out.close();
    }
    static class TaskB {
        double special(int[] loyalties, int[] levels, int playerlevelsum) {
            int poss = 1 << loyalties.length;
            double res = 0;
            for(int pos = 0; pos < poss; pos++) {
                double occurs = 1;
                int happy = 0;
                int badlevelssum = 0;
                for(int i = 0; i < loyalties.length; i++) {
                    if(((pos >> i) & 1) == 1) { //happy senator
                        happy++;
                        occurs *= (double) loyalties[i] / 100;
                    } else { //unhappy senator
                        badlevelssum += levels[i];
                        occurs *= (double) (100 - loyalties[i]) / 100;
                    }
                }
                double winprob = (happy <= levels.length / 2) ? (double) playerlevelsum / (playerlevelsum + badlevelssum) : 1;
                res += occurs * winprob;
            }
            return res;
        }

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int senators = in.readInt(); // n, [1, 8]
            int sweets = in.readInt(); // k, [1, 8]
            int playerlevelsum = in.readInt(); // A, [1, 9999]
            int[] levels = new int[senators]; // [1, 9999]
            int[] loyalties = new int[senators]; // [0, 100] divisible by 10
            IOUtils.readIntArrays(in, levels, loyalties);
            ArrayList<ArrayList<Integer>> possibilities = new ArrayList<>(Arrays.asList(new ArrayList<>()));
            for(int senator = 0; senator < senators; senator++) {
                ArrayList<ArrayList<Integer>> newpossibilities = new ArrayList<>();
                for(ArrayList<Integer> al : possibilities) {
                    int sumsofar = 0;
                    for(int val : al) sumsofar += val;
                    int minadd = senator == senators - 1 ? sweets - sumsofar : 0;
                    for(int moar = minadd; moar <= sweets - sumsofar; moar++) {
                        ArrayList<Integer> copy = new ArrayList<>(al);
                        copy.add(moar);
                        newpossibilities.add(copy);
                    }
                }
                possibilities = newpossibilities;
            }
            double res = 0;
            for(ArrayList<Integer> al : possibilities) {
                int[] newloyalties = new int[senators];
                for(int i = 0; i < senators; i++) newloyalties[i] = Math.min(100, loyalties[i] + 10 * al.get(i));
                double special = special(newloyalties, levels, playerlevelsum);
                double tot = special;
                res = Math.max(res, tot);
            }
            out.printLine(res);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if(numChars == -1)
                throw new InputMismatchException();
            if(curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch(IOException e) {
                    throw new InputMismatchException();
                }
                if(numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while(isSpaceChar(c))
                c = read();
            int sgn = 1;
            if(c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if(c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while(!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if(filter != null)
                return filter.isSpaceChar(c);
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for(int i = 0; i < objects.length; i++) {
                if(i != 0)
                    writer.print(' ');
                writer.print(objects[i]);
            }
        }

        public void printLine(Object... objects) {
            print(objects);
            writer.println();
        }

        public void close() {
            writer.close();
        }

    }

    static class IOUtils {
        public static void readIntArrays(InputReader in, int[]... arrays) {
            for(int i = 0; i < arrays[0].length; i++) {
                for(int j = 0; j < arrays.length; j++)
                    arrays[j][i] = in.readInt();
            }
        }

    }
}


import java.io.*;
import java.util.*;

public class B {

	int n, k;
	double A;
	int[] b, l;
	double ans;
	double curAns;

	void check(boolean[] used) {
		int cnt = 0;
		for (boolean t : used)
			if (t)
				cnt++;
		double prob = 1;
		for (int i = 0; i < n; i++) {
			if (used[i])
				prob *= ((double) l[i]) / ((double) 100);
			else
				prob *= 1 - ((double) l[i]) / ((double) 100);
		}
		if (2 * cnt > n) {
			curAns += prob;
		} else {
			int level = 0;
			for (int i = 0; i < n; i++)
				if (!used[i])
					level += b[i];
			curAns += prob * ( A / ((double) A + level));
		}
	}

	void go(int i, boolean[] used) {
		if (n == i) {
			check(used);
			return;
		}
		used[i] = true;
		go(i + 1, used);
		used[i] = false;
		go(i + 1, used);
	}

	void candies(int k, int i) {
		if (i == n) {
			curAns = 0;
			go(0, new boolean[n]);
			if (curAns > ans)
				ans = curAns;
			return;
		}
		candies(k, i + 1);
		for (int j = 1; j <= k && l[i] + 10 * j <= 100; j++) {
			l[i] += 10 * j;
			candies(k - j, i + 1);
			l[i] -= 10 * j;
		}
	}

	void solve() throws Exception {
		n = nextInt();
		k = nextInt();
		A = nextInt();
		b = new int[n];
		l = new int[n];
		for (int i = 0; i < n; i++) {
			b[i] = nextInt();
			l[i] = nextInt();
		}
		ans = 0;
		candies(k, 0);
		out.printf("%.12f", ans);
	}

	void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			//			in = new BufferedReader(new FileReader(filename + ".in"));
			//			out = new PrintWriter(filename + ".out");
			Locale.setDefault(Locale.US);
			solve();

			out.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	BufferedReader in;
	StringTokenizer st;
	PrintWriter out;
	final String filename = new String("B").toLowerCase();

	String nextToken() throws Exception {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}

	int nextInt() throws Exception {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws Exception {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws Exception {
		return Double.parseDouble(nextToken());
	}

	public static void main(String[] args) {
		new B().run();
	}

}


import java.util.*;

public class B {

    static int[] loyality;
    static int[] level;
    static int mid;
    static int a, n;
    static double sol;

    public static void getMax(int idx, int rem) {
        if (idx == loyality.length) {
            double pos = 0;
            for (int i = 0; i < (1 << n); i++)
                pos += solve(i);
            sol = Math.max(sol, pos);
            return;
        }
        int cur = loyality[idx];
        int r = 0;
        while (r + cur <= 10 && r <= rem) {
            loyality[idx] = cur + r;
            getMax(idx + 1, rem - r);
            r++;
        }
        loyality[idx] = cur;
    }

    public static double solve(int mask) {
        int c = 0;
        int sum = 0;
        double b = 1;
        for (int i = 0; i < n; i++) {
            if (((1 << i) | mask) == mask) {
                c++;
                b *= (loyality[i] / 10.0);
            } else {
                sum += level[i];
                b *= (1 - (loyality[i] / 10.0));
            }
        }
        if (c >= mid)
            return b;
        return b * (a * 1.0) / (a + sum);
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        int k = sc.nextInt();
        a = sc.nextInt();
        level = new int[n];
        loyality = new int[n];
        for (int i = 0; i < n; i++) {
            level[i] = sc.nextInt();
            loyality[i] = sc.nextInt() / 10;
        }
        mid = (n/2) +1;
        sol = 0;
        getMax(0, k);
        System.out.println(sol);
    }
}


/**
 * Created by IntelliJ IDEA.
 * User: Taras_Brzezinsky
 * Date: 8/13/11
 * Time: 6:10 PM
 * To change this template use File | Settings | File Templates.
 */

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
import java.io.IOException;

public class DarkAssembly extends Thread {

    public DarkAssembly() {
        this.input = new BufferedReader(new InputStreamReader(System.in));
        this.output = new PrintWriter(System.out);
        this.setPriority(Thread.MAX_PRIORITY);
    }

    static class Senator {
        int loyalty;
        int level;

        public Senator(int level, int loyalty) {
            this.level = level;
            this.loyalty = loyalty;
        }
    }

    private static double doIt(Senator[] senators, int A) {
        double probability = .0;
        for (int mask = 0; mask < (1 << senators.length); ++mask) {
            int sum = A;
            double current = 1.0;
            for (int i = 0; i < senators.length; ++i) {
                if ((mask & (1 << i)) != 0) {
                    current *= .01 * senators[i].loyalty;
                } else {
                    current *= .01 * (100 - senators[i].loyalty);
                    sum += senators[i].level;
                }
            }
            if (getOnes(mask) > senators.length / 2) {
                probability += current;
            } else {
                probability += current * (double)A / sum;
            }
        }
        return probability;
    }

    private static double go(Senator []senators, int candies, int A, int current) {
        if (current == senators.length) {
            return doIt(senators, A);
        } else {
            double result = go(senators, candies, A, current + 1);
            if (candies > 0 && senators[current].loyalty < 100) {
                senators[current].loyalty += 10;
                result = Math.max(result, go(senators, candies - 1, A, current));
                senators[current].loyalty -= 10;
            }
            return result;
        }
    }

    static int getOnes(int mask) {
        int result = 0;
        while (mask != 0) {
            mask &= mask - 1;
            ++result;
        }
        return result;
    }

    public void run() {
        try {
            int n = nextInt();
            int k = nextInt();
            int A = nextInt();
            Senator[] senators = new Senator[n];
            for (int i = 0; i < n; ++i) {
                senators[i] = new Senator(nextInt(), nextInt());
            }
            output.printf("%.10f", go(senators, k, A, 0));

            output.flush();
            output.close();

        } catch (Throwable e) {
            System.err.println(e.getMessage());
            System.err.println(Arrays.deepToString(e.getStackTrace()));
        }
    }

    public static void main(String[] args) {
        new DarkAssembly().start();
    }

    private String nextToken() throws IOException {
        while (tokens == null || !tokens.hasMoreTokens()) {
            tokens = new StringTokenizer(input.readLine());
        }
        return tokens.nextToken();
    }

    private int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    private double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    private long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    private BufferedReader input;
    private PrintWriter output;
    private StringTokenizer tokens = null;
}


import java.io.*;

import java.awt.geom.Point2D;
import java.text.*;
import java.math.*;
import java.util.*;

public class Main implements Runnable {

	final String filename = "";

	public void solve() throws Exception {
		int n = iread(), k = iread(), A = iread();
		int[] b = new int[n], l = new int[n];
		for (int i = 0; i < n; i++) {
			l[i] = iread();
			b[i] = iread();
		}

		int[] c = new int[n];
		double ans = 0.0;
		for (int mask = 0; mask < 1 << (k + n - 1); mask++) {
			int t = 0;
			for (int i = 0; i < n + k - 1; i++) {
				if ((mask & (1 << i)) != 0)
					t++;
			}
			if (t != k)
				continue;

			int x = mask;
			for (int i = 0; i < n; i++) {
				c[i] = b[i];
				while (x % 2 == 1) {
					c[i] += 10;
					x /= 2;
				}
				if (c[i] > 100)
					c[i] = 100;
				x /= 2;
			}
			double res = 0.0;
			for (int mask2 = 0; mask2 < 1 << n; mask2++) {
				int m = 0;
				double p = 1.0;
				t = 0;
				for (int i = 0; i < n; i++) {
					if ((mask2 & (1 << i)) == 0) {
						t += l[i];
						p *= (100.0 - c[i]) / 100.0;
					} else {
						p *= c[i] / 100.0;
						m++;
					}
				}
				if (m * 2 > n)
					res += p;
				else
					res += p * A * 1.0 / (A + t);
			}
			ans = Math.max(ans, res);
		}
		DecimalFormat df = new DecimalFormat("0.0000000");
		out.write(df.format(ans) + "\n");
	}

	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new BufferedWriter(new OutputStreamWriter(System.out));
			// in = new BufferedReader(new FileReader(filename+".in"));
			// out = new BufferedWriter(new FileWriter(filename+".out"));
			solve();
			out.flush();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	public int iread() throws Exception {
		return Integer.parseInt(readword());
	}

	public double dread() throws Exception {
		return Double.parseDouble(readword());
	}

	public long lread() throws Exception {
		return Long.parseLong(readword());
	}

	BufferedReader in;

	BufferedWriter out;

	public String readword() throws IOException {
		StringBuilder b = new StringBuilder();
		int c;
		c = in.read();
		while (c >= 0 && c <= ' ')
			c = in.read();
		if (c < 0)
			return "";
		while (c > ' ') {
			b.append((char) c);
			c = in.read();
		}
		return b.toString();
	}

	public static void main(String[] args) {
		try {
			Locale.setDefault(Locale.US);
		} catch (Exception e) {

		}
		// new Thread(new Main()).start();
		new Thread(null, new Main(), "1", 1 << 25).start();
	}
}


import static java.lang.Math.*;

import java.io.*;
import java.util.*;

public class flags1225 implements Runnable {
	static int n, k, a, b[], loy[];
	static boolean decision[];
	static double ans, max;

	static void check(int i) {
		if (i == n) {
			checkAgain();
			return;
		}
		decision[i] = true;
		check(i + 1);
		if (loy[i] < 100) {
			decision[i] = false;
			check(i + 1);
		}
	}

	static void checkAgain() {
		double prob = 1;
		int enemyEnergy = 0;
		int count = 0;
		for (int i = 0; i < n; i++) {
			if (decision[i]) {
				count++;
				prob *= loy[i];
			} else {
				prob = prob * (100 - loy[i]);
				enemyEnergy += b[i];
			}
		}
		double killProb = (double) (a) / (a + enemyEnergy);
		if (count > n / 2) {
			ans += prob;
			return;
		}
		prob *= killProb;
		ans += prob;
	}

	static void rec(int sum, int i) {
		if (i == n || sum == 0) {
			ans = 0;
			check(0);
			max = max(ans, max);
			return;
		}
		for (int j = 0; j <= sum; j = j + 10) {
			if (loy[i] + j > 100)
				continue;
			loy[i] += j;
			rec(sum - j, i + 1);
			loy[i] -= j;
		}
	}

	public void run() {
		n = nextInt();
		k = nextInt() * 10;
		a = nextInt();
		max = 0;
		b = new int[n];
		loy = new int[n];
		decision = new boolean[n];
		for (int i = 0; i < n; i++) {
			b[i] = nextInt();
			loy[i] = nextInt();
		}
		// System.out.println(Arrays.toString(loy));
		rec(k, 0);
		long pow = (long) pow(100, n);
		out.print((double) max / pow);

		// --------------------------------------------------------------------------------------------
		out.close();
		System.exit(0);
	}

	private static boolean fileIOMode = false;
	private static String problemName = "harmful";
	private static BufferedReader in;
	private static PrintWriter out;
	private static StringTokenizer tokenizer;

	public static void main(String[] args) throws Exception {
		Locale.setDefault(Locale.ENGLISH);
		if (fileIOMode) {
			in = new BufferedReader(new FileReader(problemName + ".in"));
			out = new PrintWriter(problemName + ".out");
		} else {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
		}
		tokenizer = new StringTokenizer("");

		new Thread(new flags1225()).start();
	}

	private static String nextLine() {
		try {
			return in.readLine();
		} catch (IOException e) {
			return null;
		}
	}

	private static String nextToken() {
		while (!tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(nextLine());
		}
		return tokenizer.nextToken();
	}

	private static double nextDouble() {
		return Double.parseDouble(nextToken());
	}

	private static int nextInt() {
		return Integer.parseInt(nextToken());
	}
}


//package round81;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;

public class B {
	Scanner in;
	PrintWriter out;
	String INPUT = "";

	void solve()
	{
		int n = ni();
		int k = ni();
		int a = ni();
		int[] lv = new int[n];
		int[] lo = new int[n];
		for(int i = 0;i < n;i++){
			lv[i] = ni();
			lo[i] = ni();
		}

		out.printf("%.9f", rec(lv, lo, n, 0, k, a));
	}

	double rec(int[] lv, int[] lo, int n, int pos, int k, int a)
	{
		if(pos == n){
			int h = n/2+1;
			double gp = 0;
			for(int i = 0;i < 1<<n;i++){
				if(Integer.bitCount(i) >= h){
					double p = 1.0;
					for(int j = 0;j < n;j++){
						if(i<<31-j<0){
							p *= (double)lo[j] / 100;
						}else{
							p *= (double)(100-lo[j]) / 100;
						}
					}
					gp += p;
				}else{
					double p = 1.0;
					int sl = 0;
					for(int j = 0;j < n;j++){
						if(i<<31-j<0){
							p *= (double)lo[j] / 100;
						}else{
							p *= (double)(100-lo[j]) / 100;
							sl += lv[j];
						}
					}
					gp += p * a/(a+sl);
				}
			}
			return gp;
		}else{
			int o = lo[pos];
			double max = 0;
			for(int i = 0;i <= k && lo[pos] <= 100;i++){
				max = Math.max(max, rec(lv, lo, n, pos+1, k-i, a));
				lo[pos]+=10;
			}
			lo[pos] = o;
			return max;
		}
	}

	void run() throws Exception
	{
		in = oj ? new Scanner(System.in) : new Scanner(INPUT);
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		tr(System.currentTimeMillis()-s+"ms");
	}

	public static void main(String[] args) throws Exception
	{
		new B().run();
	}

	int ni() { return Integer.parseInt(in.next()); }
	long nl() { return Long.parseLong(in.next()); }
	double nd() { return Double.parseDouble(in.next()); }
	boolean oj = System.getProperty("ONLINE_JUDGE") != null;
	void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}


import java.io.*;
import java.util.*;
import java.lang.reflect.Array;
import java.math.*;

public class Solution {
	private BufferedReader in;
	private PrintWriter out;
	private StringTokenizer st;
	private Random rnd;

	int[] levels;
	int[] loyal;
	int n, k;
	double A;

	int[] choices;
	int[] new_loyal;
	double[] koef;

	double ans = 0.0;
	int total;

	void rec(int step, int start) {
		if(step == k) {
			for(int i = 0; i < n; i++) {
				new_loyal[i] = loyal[i];
			}
			for(int i = 0; i < k; i++) {
				new_loyal[choices[i]] = Math.min(100, new_loyal[choices[i]] + 10);
			}

			int full = 0;

			for(int i = 0; i < n; i++) {
				if(new_loyal[i] == 100) {
					++full;
				}
			}

			if(full > (n / 2)) {
				ans = 1.0;
				return;
			}

			for(int i = 0; i < n; i++) {
				koef[i] = (double) new_loyal[i] / 100.0;
			}

			int bits_needed = (n / 2) + 1;

			double total_win = 0.0;
			double total_fights = 0.0;

			for(int mask = 0; mask < total; mask++) {
				int bits = 0;

				double win = 1.0;
				double loose = 1.0;
				double b = 0.0;

				for(int bit = 0; bit < n; bit++) {
					if((mask & (1 << bit)) != 0) {
						++bits;
						win *= koef[bit];
					} else {
						loose *= (1.0 - koef[bit]);
						b += levels[bit];
					}

				}

				double prob = win * loose;

				if(bits >= bits_needed) {
					total_win += prob;
				} else {
					total_fights += prob * (A / (A + b));
				}
			}

			ans = Math.max(ans, total_win + total_fights);

		} else {
			for(int i = start; i < n; i++) {
				choices[step] = i;
				rec(step + 1, i);
			}
		}
	}

	public void solve() throws IOException {
		n = nextInt();
		k = nextInt();
		A = nextInt();

		levels = new int[n];
		loyal = new int[n];
		new_loyal = new int[n];
		choices = new int[k];
		koef = new double[n];

		for(int i = 0; i < n; i++) {
			levels[i] = nextInt();
			loyal[i] = nextInt();
		}

		total = 1 << n;

		rec(0, 0);

		out.println(ans);
	}

	public static void main(String[] args) {
		new Solution().run();
	}

	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			st = null;
			rnd = new Random();

			solve();

			out.close();
		} catch(IOException e) {
			e.printStackTrace();
		}
	}

	private String nextToken() throws IOException, NullPointerException {
		while(st == null || !st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}

		return st.nextToken();
	}

	private int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	private long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	private double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.StringTokenizer;

public class D {
    static int n, KA, A;
    static int[] b;
    static int[] l;
    static double ans = 0;

    public static void main(String[] args) throws IOException {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        KA = in.nextInt();
        A = in.nextInt();
        b = new int[n];
        l = new int[n];

        for (int i = 0; i < l.length; i++) {
            b[i] = in.nextInt();
            l[i] = in.nextInt();
        }
        dp = new double[n + 2][n + 2][n * 9999 + 2];
        go(0, KA);
        System.out.printf("%.6f\n", ans);
    }

    public static void go(int at, int k) {
        if (at == n) {
            ans = Math.max(ans, solve(0, 0, 0));
            return;
        }
        for (int i = 0; i <= k; i++) {
            if (l[at] + i * 10 <= 100) {
                l[at] += i * 10;
                go(at + 1, k - i);
                l[at] -= i * 10;
            }
        }
    }

    static double dp[][][];

    public static double solve(int at, int ok, int B) {
        if (at == n) {
            if (ok > n / 2) {
                return 1;
            } else {
                return (A * 1.0) / (A * 1.0 + B);
            }
        }
        double ret = ((l[at]) / 100.0) * solve(at + 1, ok + 1, B)
                + (1.0 - ((l[at]) / 100.0)) * solve(at + 1, ok, B + b[at]);
        return ret;
    }

    // 3 0 31
    // 10 60
    // 12 60
    // 15 0
    static class InputReader {
        BufferedReader in;
        StringTokenizer st;

        public InputReader() throws IOException {
            in = new BufferedReader(new InputStreamReader(System.in));
            st = new StringTokenizer(in.readLine());
        }

        public String next() throws IOException {
            while (!st.hasMoreElements())
                st = new StringTokenizer(in.readLine());
            return st.nextToken();
        }

        public int nextInt() throws NumberFormatException, IOException {
            return Integer.parseInt(next());
        }

        public long nextLong() throws NumberFormatException, IOException {
            return Long.parseLong(next());
        }
    }
}


/**
 * Created by IntelliJ IDEA.
 * User: piyushd
 * Date: 3/26/11
 * Time: 10:53 PM
 * To change this template use File | Settings | File Templates.
 */

public class TaskB {

    int[] levels;
    int[] loyalty;

    int n, k, A;
    double ans = Double.NEGATIVE_INFINITY;

    void rec(int ix, int sweets, int[] loyalty) {
        if (ix == n) {

            double nres = 0.0;
            for(int mask = 0; mask < (1<<n); mask++) {

                double res = 1.0, totalStrength = 0;
                for (int i = 0; i < n; i++) {
                    if ((mask & (1 << i)) > 0) {
                        res *= loyalty[i] / 100.0;
                    } else {
                        res *= 1.0 - (loyalty[i]/ 100.0);
                        totalStrength += levels[i];
                    }
                }

                int bitCount = Integer.bitCount(mask);
                if(bitCount > n / 2) {
                    nres += res;
                }
                else {
                    nres += res * (A) / (A + totalStrength);
                }

            }
            ans = Math.max(ans, nres);
            return;
        }

        for (int j = 0; j <= sweets; j++) {
            if (loyalty[ix] + 10 * j > 100) break;
            int[] nloyalty = loyalty.clone();
            nloyalty[ix] += 10 * j;
            rec(ix + 1, sweets - j, nloyalty);
        }
    }

    void run() {
        n = nextInt();
        k = nextInt();
        A = nextInt();
        levels = new int[n];
        loyalty = new int[n];
        for (int i = 0; i < n; i++) {
            levels[i] = nextInt();
            loyalty[i] = nextInt();
        }

        rec(0, k, loyalty);
        System.out.println(ans);
    }

    int nextInt() {
        try {
            int c = System.in.read();
            if (c == -1) return c;
            while (c != '-' && (c < '0' || '9' < c)) {
                c = System.in.read();
                if (c == -1) return c;
            }
            if (c == '-') return -nextInt();
            int res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = System.in.read();
            } while ('0' <= c && c <= '9');
            return res;
        } catch (Exception e) {
            return -1;
        }
    }

    long nextLong() {
        try {
            int c = System.in.read();
            if (c == -1) return -1;
            while (c != '-' && (c < '0' || '9' < c)) {
                c = System.in.read();
                if (c == -1) return -1;
            }
            if (c == '-') return -nextLong();
            long res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = System.in.read();
            } while ('0' <= c && c <= '9');
            return res;
        } catch (Exception e) {
            return -1;
        }
    }

    double nextDouble() {
        return Double.parseDouble(next());
    }

    String next() {
        try {
            StringBuilder res = new StringBuilder("");
            int c = System.in.read();
            while (Character.isWhitespace(c))
                c = System.in.read();
            do {
                res.append((char) c);
            } while (!Character.isWhitespace(c = System.in.read()));
            return res.toString();
        } catch (Exception e) {
            return null;
        }
    }

    String nextLine() {
        try {
            StringBuilder res = new StringBuilder("");
            int c = System.in.read();
            while (c == '\r' || c == '\n')
                c = System.in.read();
            do {
                res.append((char) c);
                c = System.in.read();
            } while (c != '\r' && c != '\n');
            return res.toString();
        } catch (Exception e) {
            return null;
        }
    }

    public static void main(String[] args) {
        new TaskB().run();
    }
}


/**
 * Created by IntelliJ IDEA.
 * User: Taras_Brzezinsky
 * Date: 8/13/11
 * Time: 6:10 PM
 * To change this template use File | Settings | File Templates.
 */

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
import java.io.IOException;

public class DarkAssembly extends Thread {

    public DarkAssembly() {
        this.input = new BufferedReader(new InputStreamReader(System.in));
        this.output = new PrintWriter(System.out);
        this.setPriority(Thread.MAX_PRIORITY);
    }

    class Senator {
        int loyalty;
        int level;

        public Senator(int level, int loyalty) {
            this.level = level;
            this.loyalty = loyalty;
        }
    }

    private static double doIt(Senator[] senators, int A) {
        double probability = .0;
        for (int mask = 0; mask < (1 << senators.length); ++mask) {
            int sum = A;
            double current = 1.0;
            for (int i = 0; i < senators.length; ++i) {
                if ((mask & (1 << i)) != 0) {
                    current *= .01 * senators[i].loyalty;
                } else {
                    current *= .01 * (100 - senators[i].loyalty);
                    sum += senators[i].level;
                }
            }
            if (getOnes(mask) > senators.length / 2) {
                probability += current;
            } else {
                probability += current * (double)A / sum;
            }
        }
        return probability;
    }

    private static double go(Senator []senators, int candies, int A, int current) {
        if (current == senators.length) {
            return doIt(senators, A);
        } else {
            double result = go(senators, candies, A, current + 1);
            if (candies > 0 && senators[current].loyalty < 100) {
                senators[current].loyalty += 10;
                result = Math.max(result, go(senators, candies - 1, A, current));
                senators[current].loyalty -= 10;
            }

            return result;
        }
    }

    static int getOnes(int mask) {
        int result = 0;
        while (mask != 0) {
            mask &= mask - 1;
            ++result;
        }
        return result;
    }

    public void run() {
        try {
            int n = nextInt();
            int k = nextInt();
            int A = nextInt();
            Senator[] senators = new Senator[n];
            for (int i = 0; i < n; ++i) {
                senators[i] = new Senator(nextInt(), nextInt());
            }
            output.printf("%.10f", go(senators, k, A, 0));

            output.flush();
            output.close();

        } catch (Throwable e) {
            System.err.println(e.getMessage());
            System.err.println(Arrays.deepToString(e.getStackTrace()));
        }
    }

    public static void main(String[] args) {
        new DarkAssembly().start();
    }

    private String nextToken() throws IOException {
        while (tokens == null || !tokens.hasMoreTokens()) {
            tokens = new StringTokenizer(input.readLine());
        }
        return tokens.nextToken();
    }

    private int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    private double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    private long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    private BufferedReader input;
    private PrintWriter output;
    private StringTokenizer tokens = null;
}


import java.util.*;

public class B
{
   public static void main(String[] args)
   {
      new B(new FastScanner());
   }

   int hash(int i, int[] cc)
   {
      int res = i;
      for (int ii : cc)
      {
         res *= 8;
         res += ii;
      }

      return res;
   }

   int N, K, A;
   int[] lvl;
   int[] vs; // loyalty

   double calc(int i, int[] cc)
   {
      // Find the probability of winning
      double res = 0;

      int cnt = 0;
      for (int m=0; m<1<<N; m++)
      {
         double pt = 1.0;
         boolean passed = true;
         int nG = 0;

         int lvlcnt = 0;
         for (int j=0; j<N; j++)
         {
            int p = 10*cc[j]+vs[j];
            int u = m&(1<<j);

            boolean votesGood = (u > 0);
            if (votesGood)
               nG++;
            else
               lvlcnt += lvl[j];

            if ((p == 0)&&(votesGood))
               passed = false;
            if ((p == 100)&&(!votesGood))
               passed = false;
            if (!passed)
               break;

            if (votesGood)
               pt *= (p/100.0);
            else
               pt *= ((100-p)/100.0);
         }

         if (passed == false)
            continue;

         if (2*nG <= N)
         {
            // Calculate if we kill all senators
            double p1 = A/(1.0*(A+lvlcnt));

            // Add in the probability of losing
            res += (1-p1)*pt;
         }
      }

      return 1.0-res;
   }

   HashMap<Integer, Double> memo;
   double go(int i, int[] cc)
   {
      if (i == -1)
         return calc(i, cc);

      int hv = hash(i, cc);
      Double rr = memo.get(hv);
      if (rr != null)
         return rr;

      double res = go(i-1, cc);
      for (int j=0; j<N; j++)
      {
         int cv = vs[j]+cc[j]*10;
         if (cv == 100)
            continue;

         cc[j]++;
         double rrr = go(i-1, cc);
         cc[j]--;

         if (rrr > res)
            res = rrr;
      }

      memo.put(hv, res);
      return res;
   }

   public B(FastScanner in)
   {
      N = in.nextInt();
      K = in.nextInt();
      A = in.nextInt();
      memo = new HashMap<Integer, Double>();

      lvl = new int[N];
      vs = new int[N];
      for (int i=0; i<N; i++)
      {
         lvl[i] = in.nextInt();
         vs[i] = in.nextInt();
      }

      int[] cs = new int[8];
      double res = go(K-1, cs);
      System.out.printf("%.10f%n", res);
   }
}

class FastScanner{
    int nextInt(){
        try{
            int c=System.in.read();
            if(c==-1) return c;
            while(c!='-'&&(c<'0'||'9'<c)){
                c=System.in.read();
                if(c==-1) return c;
            }
            if(c=='-') return -nextInt();
            int res=0;
            do{
                res*=10;
                res+=c-'0';
                c=System.in.read();
            }while('0'<=c&&c<='9');
            return res;
        }catch(Exception e){
            return -1;
        }
    }

    long nextLong(){
        try{
            int c=System.in.read();
            if(c==-1) return -1;
            while(c!='-'&&(c<'0'||'9'<c)){
                c=System.in.read();
                if(c==-1) return -1;
            }
            if(c=='-') return -nextLong();
            long res=0;
            do{
                res*=10;
                res+=c-'0';
                c=System.in.read();
            }while('0'<=c&&c<='9');
            return res;
        }catch(Exception e){
            return -1;
        }
    }

    double nextDouble(){
        return Double.parseDouble(next());
    }

    String next(){
        try{
            StringBuilder res=new StringBuilder("");
            int c=System.in.read();
            while(Character.isWhitespace(c))
                c=System.in.read();
            do{
                res.append((char)c);
            }while(!Character.isWhitespace(c=System.in.read()));
            return res.toString();
        }catch(Exception e){
            return null;
        }
    }

    String nextLine(){
        try{
            StringBuilder res=new StringBuilder("");
            int c=System.in.read();
            while(c=='\r'||c=='\n')
                c=System.in.read();
            do{
                res.append((char)c);
                c=System.in.read();
            }while(c!='\r'&&c!='\n');
            return res.toString();
        }catch(Exception e){
            return null;
        }
    }
}


import java.io.*;
import java.util.*;

public class B {
	static double max;
	static int n, A, b[], l[];
	static int sw[];
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		int k = sc.nextInt();
		A = sc.nextInt();
		b = new int[n];
		l = new int[n];
		sw = new int[n];
		for(int i=0; i<n; i++) {
			b[i] = sc.nextInt();
			l[i] = sc.nextInt();
		}
		max = 0;
		search(k, 0);
		System.out.println(max);
	}

	static void search(int k, int m) {
		if(max == 1) return;
		if(m == n) {
			if(k > 0) return;
			double pr[] = new double[n];
			for(int i=0; i<n; i++) {
				pr[i] = Math.min(100, l[i] + 10*sw[i])*1./100;
			}
			double ex = 0;
			for(int i=0; i<1<<n; i++) {
				double p = 1;
				int cnt = 0;
				int lv = 0;
				for(int j=0; j<n; j++) {
					if((i&(1<<j))>0) {
						p *= pr[j];
						cnt++;
					}
					else {
						p *= (1-pr[j]);
						lv += b[j];
					}
				}
				if(cnt > n/2) {
					ex += p;
				}
				else {
					ex += p*A/(A+lv);
				}
			}
			max = Math.max(max, ex);
			return;
		}
		for(int i=k; i>=0; i--) {
			sw[m] = i;
			search(k-i, m+1);
		}
	}

	static class Scanner {
		BufferedReader br;
		StringTokenizer st;

		Scanner(InputStream in) {
			br = new BufferedReader(new InputStreamReader(in));
			eat("");
		}

		void eat(String s) {
			st = new StringTokenizer(s);
		}

		String nextLine() {
			try {
				return br.readLine();
			} catch (IOException e) {
				throw new IOError(e);
			}
		}

		boolean hasNext() {
			while (!st.hasMoreTokens()) {
				String s = nextLine();
				if (s == null)
					return false;
				eat(s);
			}
			return true;
		}

		String next() {
			hasNext();
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}
	}
}


import java.awt.geom.*;
import java.io.*;
import java.math.*;
import java.util.*;
import java.util.regex.*;
import static java.lang.Math.*;
public class B {

    public static void swap(int[] array, int a, int b) { // {{{
        int t = array[a];
        array[a] = array[b];
        array[b] = t;
    } // }}}

    int n, k, A;
    int[] b;
    int[] l;

    double ans;

    double cal() {
        double total = 0;
        for (int mask=0;mask<(1<<n);mask++) {
            int bit = Integer.bitCount(mask);
            double p = 1;
            for (int i=0;i<n;i++) {
                if ((mask&(1<<i))!=0)
                    p *= l[i]/10.0;
                else
                    p *= 1.0-l[i]/10.0;
            }

            if (bit*2>n)
                total += p;
            else {
                int B = 0;
                for (int i=0;i<n;i++) {
                    if ((mask&(1<<i))==0) {
                        B += b[i];
                    }
                }
                total += p*(A/(double)(A+B));
            }
        }
        return total;
    }

    void rec(int d, int remain) {
        ans = max(ans, cal());
        if (remain==0) return;
        for (int i=d;i<n;i++) {
            if (l[i]==10) continue;
            l[i]++;
            rec(i, remain-1);
            l[i]--;
        }
    }

    public B() throws Exception {
        n = in.nextInt();
        k = in.nextInt();
        A = in.nextInt();

        b = new int[n];
        l = new int[n];
        for (int i=0;i<n;i++) {
            b[i] = in.nextInt();
            l[i] = in.nextInt()/10;
        }

        ans = 0;
        rec(0, k);

        System.out.print(ans);
    }

    Scanner in = new Scanner(System.in);
    StringBuilder buf = new StringBuilder();
    public static void main(String[] args) throws Exception { // {{{
        new B();
    } // }}}
    public static void debug(Object... arr) { // {{{
        System.err.println(Arrays.deepToString(arr));
    } // }}}
}


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

import java.io.*;
import java.util.*;

public class B {

	private void solve() throws IOException {
		int senators = nextInt();
		int candies = nextInt();
		scoreA = nextInt();
		lvl = new int[senators];
		unloyal = new int[senators];
		for (int i = 0; i < senators; i++) {
			lvl[i] = nextInt();
			unloyal[i] = 10 - nextInt() / 10;
		}
		n = senators;
		give = new int[n];
		res = 0;
		go(0, candies);
		out.println(res);
	}

	static double res;
	static int[] lvl;
	static int[] unloyal;
	static int[] give;
	static int n;
	static int scoreA;

	static double probability() {
		double res = 0;
		for (int mask = 0; mask < 1 << n; mask++) {
			double p = 1;
			int scoreB = 0;
			int cntGood = Integer.bitCount(mask);
			for (int i = 0; i < n; i++) {
				int cnt = unloyal[i] - give[i];
				if ((mask & (1 << i)) == 0) {
					scoreB += lvl[i];
					p *= cnt * .1;
				} else {
					p *= (10 - cnt) * .1;
				}
			}
			if (2 * cntGood > n) {
				res += p;
			} else {
				res += p * scoreA / (scoreA + scoreB);
			}
		}
		return res;
	}

	static void go(int man, int candies) {
		if (man == n) {
			res = max(res, probability());
			return;
		}
		give[man] = 0;
		go(man + 1, candies);
		for (int i = 1; i <= min(unloyal[man], candies); i++) {
			give[man] = i;
			go(man + 1, candies - i);
		}
	}

	public static void main(String[] args) {
		try {
			br = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			new B().solve();
			out.close();
		} catch (Throwable e) {
			e.printStackTrace();
			System.exit(239);
		}
	}

	static BufferedReader br;
	static StringTokenizer st;
	static PrintWriter out;

	static String nextToken() throws IOException {
		while (st == null || !st.hasMoreTokens()) {
			String line = br.readLine();
			if (line == null) {
				return null;
			}
			st = new StringTokenizer(line);
		}
		return st.nextToken();
	}

	static int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	static long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	static double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
}


import java.util.*;

public class b {
	static int n,k,A;
	static int[] l,p;
	static double [][][] memo;
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		n = in.nextInt();
		k = in.nextInt();
		A = in.nextInt();
		memo = new double[n+1][n+1][1<<n];
		l = new int[n];
		p = new int[n];
		for(int i=0; i<n; i++) {
			l[i] = in.nextInt();
			p[i] = in.nextInt();
		}
		System.out.printf("%.10f%n",go(0,k));
	}
	static double go(int pos, int left) {
		if(pos==n) {
			for(int i=0; i<=n; i++)
				for(int j=0; j<=n; j++)
					Arrays.fill(memo[i][j],-1);
			return go2(0,n/2+1,0);
		}
		double best = go(pos+1,left);
		if(left == 0) return best;
		if(p[pos] < 100) {
			p[pos] += 10;
			best = Math.max(best, go(pos,left-1));
			p[pos] -= 10;
		}
		return best;
	}
	static double go2(int pos, int needed, int mask) {
		if(needed == 0) return 1.0;
		if(pos == n) {
			int tot = 0;
			for(int i=0; i<n; i++)
				if((mask&(1<<i))!=0)
					tot += l[n-i-1];
			return (A)/(A+tot+0.0);
		}
		if(memo[pos][needed][mask] != -1)
			return memo[pos][needed][mask];
		double a = (p[pos]/100.)*go2(pos+1,needed-1,mask*2);
		double b = (1-(p[pos]/100.))*go2(pos+1,needed,mask*2+1);
		return memo[pos][needed][mask] = a+b;
	}
}


import java.awt.*;
import java.io.*;
import java.math.*;
import java.util.*;
import static java.lang.Math.*;

public class BetaRound81_B implements Runnable {

    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    public static void main(String[] args) {
        new Thread(null, new BetaRound81_B(), "", 256 * (1L << 20)).start();
    }

    public void run() {
        try {
            long t1 = System.currentTimeMillis();
            if (System.getProperty("ONLINE_JUDGE") != null) {
                in = new BufferedReader(new InputStreamReader(System.in));
                out = new PrintWriter(System.out);
            } else {
                in = new BufferedReader(new FileReader("input.txt"));
                out = new PrintWriter("output.txt");
            }
            Locale.setDefault(Locale.US);
            solve();
            in.close();
            out.close();
            long t2 = System.currentTimeMillis();
            System.err.println("Time = " + (t2 - t1));
        } catch (Throwable t) {
            t.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    /** http://pastebin.com/j0xdUjDn */
    static class Utils {

        private Utils() {}

        public static void mergeSort(int[] a) {
            mergeSort(a, 0, a.length - 1);
        }

        private static final int MAGIC_VALUE = 50;

        private static void mergeSort(int[] a, int leftIndex, int rightIndex) {
            if (leftIndex < rightIndex) {
                if (rightIndex - leftIndex <= MAGIC_VALUE) {
                    insertionSort(a, leftIndex, rightIndex);
                } else {
                    int middleIndex = (leftIndex + rightIndex) / 2;
                    mergeSort(a, leftIndex, middleIndex);
                    mergeSort(a, middleIndex + 1, rightIndex);
                    merge(a, leftIndex, middleIndex, rightIndex);
                }
            }
        }

        private static void merge(int[] a, int leftIndex, int middleIndex, int rightIndex) {
            int length1 = middleIndex - leftIndex + 1;
            int length2 = rightIndex - middleIndex;
            int[] leftArray = new int[length1];
            int[] rightArray = new int[length2];
            System.arraycopy(a, leftIndex, leftArray, 0, length1);
            System.arraycopy(a, middleIndex + 1, rightArray, 0, length2);
            for (int k = leftIndex, i = 0, j = 0; k <= rightIndex; k++) {
                if (i == length1) {
                    a[k] = rightArray[j++];
                } else if (j == length2) {
                    a[k] = leftArray[i++];
                } else {
                    a[k] = leftArray[i] <= rightArray[j] ? leftArray[i++] : rightArray[j++];
                }
            }
        }

        private static void insertionSort(int[] a, int leftIndex, int rightIndex) {
            for (int i = leftIndex + 1; i <= rightIndex; i++) {
                int current = a[i];
                int j = i - 1;
                while (j >= leftIndex && a[j] > current) {
                    a[j + 1] = a[j];
                    j--;
                }
                a[j + 1] = current;
            }
        }

    }

    // solution

    int n, k, A;
    int[] b, l, c;

    void solve() throws IOException {
        n = readInt();
        k = readInt();
        A = readInt();
        b = new int[n];
        l = new int[n];
        for (int i = 0; i < n; i++) {
            b[i] = readInt();
            l[i] = readInt();
        }
        c = new int[n];
        rec(0, 0);
        out.printf("%.12f\n", ans);
    }

    double ans = 0;

    void rec(int sum, int i) {
        if (i > n) return;
        if (sum > k) return;
        if (i == n) {
            ans = max(ans, p());
            return;
        }
        if (l[i] + c[i]*10 <= 100) {
            int can = min(k - sum, (100 - (l[i] + c[i]*10)) / 10);
            for (int set = can; set >= 0; set--) {
                c[i] += set;
                rec(sum + set, i + 1);
                c[i] -= set;
            }
        }
    }

    double p() {
        int n = c.length;
        int need = n / 2 + 1;
        int[] L = new int[n];
        for (int i = 0; i < n; i++) {
            L[i] = l[i] + c[i]*10;
            if (L[i] > 100) {
                throw new RuntimeException();
            }
        }

        double p = 0;
        for (int mask = 0; mask < (1 << n); mask++) {
            double q = 1;
            for (int i = 0; i < n; i++) {
                if (((1 << i) & mask) != 0) {
                    q *= L[i] / 100.0;
                } else {
                    q *= 1 - (L[i] / 100.0);
                }
            }
            if (q == 0) continue;
            if (Integer.bitCount(mask) >= need) {
                p += q;
            } else {
                int B = 0;
                for (int i = 0; i < n; i++) {
                    if (((1 << i) & mask) == 0) {
                        B += b[i];
                    }
                }
                double q2 = ((double) A) / (A + B);
                p += q * q2;
            }
        }
        return p;
    }

}


import java.io.InputStreamReader;
import java.io.IOException;
import java.util.InputMismatchException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.Writer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Niyaz Nigmatullin
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		FastScanner in = new FastScanner(inputStream);
		FastPrinter out = new FastPrinter(outputStream);
		TaskB solver = new TaskB();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskB {

    static int myLevel;
    static int[] level;
    static int[] loyalty;

    static double get(int n) {
        double ret = 0;
        for (int mask = 0; mask < 1 << n; mask++) {
            int k = Integer.bitCount(mask);
            double prob = 1.;
            int sum = 0;
            for (int i = 0; i < n; i++) {
                if (((mask >> i) & 1) == 1) {
                    prob *= loyalty[i] * .1;
                } else {
                    prob *= (10 - loyalty[i]) * .1;
                    sum += level[i];
                }
            }
            if (k * 2 > n) {
                ret += prob;
            } else {
                ret += prob * myLevel / (myLevel + sum);
            }
        }
        return ret;
    }

    static double go(int x, int k, int n) {
        if (x == n) {
            return get(n);
        }
        double ret = 0;
        for (int i = 0; i <= k && loyalty[x] + i <= 10; i++) {
            loyalty[x] += i;
            ret = Math.max(go(x + 1, k - i, n), ret);
            loyalty[x] -= i;
        }
        return ret;
    }

    public void solve(int testNumber, FastScanner in, FastPrinter out) {
        int n = in.nextInt();
        int k = in.nextInt();
        myLevel = in.nextInt();
        level = new int[n];
        loyalty = new int[n];
        for (int i = 0; i < n; i++) {
            level[i] = in.nextInt();
            loyalty[i] = in.nextInt() / 10;
        }
        out.println(go(0, k, n));
    }
}

class FastScanner extends BufferedReader {

    boolean isEOF;

    public FastScanner(InputStream is) {
        super(new InputStreamReader(is));
    }

    public int read() {
        try {
            int ret = super.read();
            if (isEOF && ret < 0) {
                throw new InputMismatchException();
            }
            isEOF = ret == -1;
            return ret;
        } catch (IOException e) {
            throw new InputMismatchException();
        }
    }

    static boolean isWhiteSpace(int c) {
        return c >= -1 && c <= 32;
    }

    public int nextInt() {
        int c = read();
        while (isWhiteSpace(c)) {
            c = read();
        }
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int ret = 0;
        while (!isWhiteSpace(c)) {
            if (c < '0' || c > '9') {
                throw new NumberFormatException("digit expected " + (char) c
                        + " found");
            }
            ret = ret * 10 + c - '0';
            c = read();
        }
        return ret * sgn;
    }

    }

class FastPrinter extends PrintWriter {

    public FastPrinter(OutputStream out) {
        super(out);
    }

    public FastPrinter(Writer out) {
        super(out);
    }

}


/**
 *
 * @author Saransh
 */
import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;

public class Main
{
    static int senator_attr[][];
    static int senators;
    static double A;
    public static void main(String[] args)
    {
        try
        {
            Parserdoubt pd=new Parserdoubt(System.in);
            PrintWriter pw=new PrintWriter(System.out);
            senators=pd.nextInt();
            int candies=pd.nextInt();
            senator_attr=new int[senators][2];
            A=pd.nextInt();
            for(int i=0;i<senators;i++)
            {
                senator_attr[i][0]=pd.nextInt();
                senator_attr[i][1]=pd.nextInt();
            }
            max=-1;
            make(0,candies,new int[senators]);
            //print(maxer);
            System.out.printf("%.10f",max);
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    static double max;
    static int maxer[];
    public static void get(int a[])
    {
        maxer=new int[senators];
        for(int i=0;i<maxer.length;i++)
            maxer[i]=a[i];
    }
    public static void make(int pos,int left,int arr[])
    {
        if(pos==senators-1)
        {
            arr[pos]=left;
            //print(arr);
            double f=calc(arr);
            if(f>max)
            {
                max=f;
              get(arr);
            }

            return;
        }
        if(left==0)
        {
            //print(arr);
            double f=calc(arr);
            if(f>max)
            {
                max=f;
                get(arr);
            }

            return;
        }
        for(int i=0;i<=left;i++)
        {
            arr[pos]=i;
            make(pos+1,left-i,arr);
            arr[pos]=0;
        }
    }
    public static double calc(int arr[])
    {
       // print(arr);
        int tmp[][]=new int[senators][2];
        for(int i=0;i<senators;i++)
        {
            tmp[i][0]=senator_attr[i][0];
            tmp[i][1]=Math.min(senator_attr[i][1]+arr[i]*10, 100);
           // System.out.println(tmp[i][0]+" "+tmp[i][1]);
        }
        //print(tmp[0]);
        return prob(tmp);
    }
    public static void print(int a[])
    {
        for(int i=0;i<a.length;i++)
            System.out.print(a[i]+" ");
        System.out.println();

    }
    public static double prob(int arr[][])
    {
        double probability=0.0;
        for(int i=0;i<(1<<senators);i++)
        {
            if(Integer.bitCount(i)>senators/2)
            {
                double add=1.0;
                int tmpi=i;
                for(int p=0;p<senators;p++)
                {
                    if(tmpi%2==1)
                    {
                        add*=arr[p][1]/100.0;
                    }
                    else
                    {
                        add*=(100-arr[p][1])/100.0;
                    }
                    tmpi/=2;
                }
                probability+=add;
                //System.out.println(i+" "+add);
            }
            else
            {
                double add=1.0;
                double B=0;
                int tmpi=i;
                for(int p=0;p<senators;p++)
                {
                    if(tmpi%2==1)
                    {
                        add*=arr[p][1]/100.0;
                    }
                    else
                    {
                        add*=(100-arr[p][1])/100.0;
                        B+=arr[p][0];
                    }
                    tmpi/=2;
                }
                add*=A/(A+B);
                probability+=add;
                //System.out.println(i+" "+add);
            }

        }
        return probability;
    }
}

class Skill implements Comparable<Skill>
{
    String name;
    int v;
    public Skill(String n,int val)
    {
        name=n;
        v=val;
    }
    public int compareTo(Skill k)
    {
        return -k.name.compareTo(name);
    }
}
class Parserdoubt
    {
       final private int BUFFER_SIZE = 1 << 17;

       private DataInputStream din;
       private byte[] buffer;
       private int bufferPointer, bytesRead;

       public Parserdoubt(InputStream in)
       {
          din = new DataInputStream(in);
          buffer = new byte[BUFFER_SIZE];
          bufferPointer = bytesRead = 0;
       }
       public String nextString() throws Exception
       {
           StringBuffer sb=new StringBuffer("");
           byte c = read();
           while (c <= ' ') c = read();
           do
           {
               sb.append((char)c);
               c=read();
           }while(c>' ');
           return sb.toString();
       }

       public char nextChar() throws Exception
       {
           byte c=read();
           while(c<=' ') c= read();
           return (char)c;
       }
       public int nextInt() throws Exception
       {
          int ret = 0;
          byte c = read();
          while (c <= ' ') c = read();
          boolean neg = c == '-';
          if (neg) c = read();
          do
          {
              ret = ret * 10 + c - '0';
             c = read();
          } while (c > ' ');
          if (neg) return -ret;
          return ret;
       }
       public long nextLong() throws Exception
       {
          long ret = 0;
          byte c = read();
          while (c <= ' ') c = read();
          boolean neg = c == '-';
          if (neg) c = read();
          do
          {
              ret = ret * 10 + c - '0';
             c = read();
          } while (c > ' ');
          if (neg) return -ret;
          return ret;
       }
       private void fillBuffer() throws Exception
       {
          bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
          if (bytesRead == -1) buffer[0] = -1;
       }

       private byte read() throws Exception
       {
          if (bufferPointer == bytesRead) fillBuffer();
          return buffer[bufferPointer++];
       }
    }


import static java.util.Arrays.*;
import static java.lang.Math.*;
import static java.math.BigInteger.*;
import java.util.*;
import java.math.*;
import java.io.*;

public class B implements Runnable
{
    String file = "input";

    boolean TEST = false;
    double EPS = 1e-8;
    void solve() throws IOException
    {
        int n = nextInt(), k = nextInt(), A = nextInt();
        int[] level = new int[n];
        int[] loyal = new int[n];
        for(int i = 0; i < n; i++)
        {
            level[i] = nextInt();
            loyal[i] = nextInt();
        }
        double res = 0;
        for(int mask = 0; mask < 1 << (n + k - 1); mask++)
        {
            if(Integer.bitCount(mask) != k) continue;

            int[] L = new int[n];
            int x = mask;
            for(int i = 0; i < n; i++)
            {
                L[i] = loyal[i];
                while(x % 2 == 1)
                {
                    L[i] += 10;
                    x /= 2;
                }
                L[i] = min(L[i], 100);
                x /= 2;
            }
            double tmp = 0;
            for(int w = 0; w < 1 << n; w++)
            {
                double p = 1.;
                double B = 0;
                for(int i = 0; i < n; i++)
                    if((w >> i & 1) != 0) p *= L[i] / 100.;
                    else
                    {
                        p *= (100 - L[i]) / 100.;
                        B += level[i];
                    }
                if(Integer.bitCount(w) * 2 > n) tmp += p;
                else tmp += p * (A / (A + B));
            }
            res = max(res, tmp);
        }
        out.printf("%.8f\n", res);
    }

    class Player
    {

    }

    String next() throws IOException
    {
        while(st == null || !st.hasMoreTokens()) st = new StringTokenizer(input.readLine());
        return st.nextToken();
    }

    int nextInt() throws IOException
    {
        return Integer.parseInt(next());
    }

    long nextLong() throws IOException
    {
        return Long.parseLong(next());
    }

    double nextDouble() throws IOException
    {
        return Double.parseDouble(next());
    }

    void print(Object... o)
    {
        System.out.println(deepToString(o));
    }

    void gcj(Object o)
    {
        String s = String.valueOf(o);
        out.println("Case #" + test + ": " + s);
        System.out.println("Case #" + test + ": " + s);
    }

    BufferedReader input;
    PrintWriter out;
    StringTokenizer st;
    int test;

    void init() throws IOException
    {
        if(TEST) input = new BufferedReader(new FileReader(file + ".in"));
        else input = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(new BufferedOutputStream(System.out));
    }

    public static void main(String[] args) throws IOException
    {
        new Thread(null, new B(), "", 1 << 20).start();
    }

    public void run()
    {
        try
        {
            init();
            if(TEST)
            {
                int runs = nextInt();
                for(int i = 0; i < runs; i++) solve();
            }
            else solve();
            out.close();
        }
        catch(Exception e)
        {
            e.printStackTrace();
            System.exit(1);
        }
    }
}


import java.io.*;
import java.util.*;

public class B2 {
	String s = null;

	String[] ss = null;
	int[][] sn = null;
	int n = 0;
	double ans = 1;
	int A = 0;
	public void run() throws Exception{

		BufferedReader br = null;
		File file = new File("input.txt");
		if(file.exists()){
			br = new BufferedReader(new FileReader("input.txt"));
		}
		else{
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		s = br.readLine();
		ss = s.split(" ");

		n = Integer.parseInt(ss[0]);
		int k = Integer.parseInt(ss[1]);
		A = Integer.parseInt(ss[2]);
		sn = new int[n][2];

		for(int i = 0; i < n; i++){
			s = br.readLine();
			ss = s.split(" ");
			sn[i][0] = Integer.parseInt(ss[0]);
			sn[i][1] = Integer.parseInt(ss[1]);
		}

		int num = 0;
		for(int i = 0; i < n; i++){
			num += (100 - sn[i][1]) / 10;
		}
		if(k >= num){
			System.out.println("1.0");
			return;
		}

		check(0, k, sn);

		ans = 1 - ans;
		System.out.println(ans);

	}

	void check(int i, int k, int[][] sn){
		if(i == n && k == 0){
			check2(sn);
			return;
		}
		else if(i == n && k > 0){
			return;
		}
		else if(k == 0){
			check(i+1, k, sn);
		}
		else{
			for(int j = 0; j <= k; j++){
				if(sn[i][1] + j * 10 <= 100){
					int[][] nsn = copy(sn);
					nsn[i][1] += j * 10;
					check(i+1, k - j, nsn);
				}
			}
		}
	}

	void check2(int[][] sn){
		List<Integer> target = new ArrayList<Integer>();
		int h = 0;
		for(int i = 0; i < sn.length; i++){
			if(sn[i][1] != 100){
				target.add(i);
			}
			else{
				h++;
			}
		}
		if(h  > n / 2){
			System.out.println("1.0");
			System.exit(0);
		}
		int makemax = n - h;
		int makemin = (n+1)/2;
		double ma = 0;
		for(int i = makemax; i >= makemin; i--){
			Combination c = new Combination(makemax, i);
			Iterator<int[]> ite = c.iterator();

			while(ite.hasNext()){
				int[] ret = ite.next();
				Set<Integer> make = new HashSet<Integer>();
				for(int j = 0; j < ret.length; j++){
					if(ret[j] > 0){
						make.add(target.get(j));
					}
				}
				double makeK = 1;
				int B = 0;
				for(int j = 0; j < n; j++){
					int perc = 0;
					if(make.contains(j)){
						perc = 100 - sn[j][1];
						B += sn[j][0];
					}
					else{
						perc = sn[j][1];
					}
					makeK *= ((double)perc / 100);
				}
				ma += makeK * (1 - (double)A/(A+B));
			}

		}
		ans = Math.min(ans, ma);
	}

	int[][] copy(int[][] sn){
		int[][] csn = new int[sn.length][2];

		for(int i = 0; i < sn.length; i++){
			csn[i][0] = sn[i][0];
			csn[i][1] = sn[i][1];
		}

		return csn;
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception{
		B2 t = new B2();
		t.run();

	}

	public class Combination implements Iterable<int[]> {
		private final int max;
		private final int select;

		public Combination(int max, int select) {
			if (max < 1 || 62 < max) {
				throw new IllegalArgumentException();
			}
			this.max = max;
			this.select = select;
		}

		public Iterator<int[]> iterator() {
			return new CombinationIterator(max, select);
		}

		private class CombinationIterator implements Iterator<int[]> {
			private long value;
			private final long max;
			private final int size;
			private int[] ret = null;
			public CombinationIterator(int max, int select) {
				this.value = (1L << select) - 1L;
				this.size = max;
				this.max = 1L << max;
				this.ret = new int[size];
			}

			public boolean hasNext() {
				return value < max;
			}

			public int[] next() {
				long stock = value;
				value = next(value);

				for(int i = 0; i < size; i++){
					long tmp = stock >> i;
					tmp = tmp & 1;
					ret[i] = (int)tmp;
				}

				return ret;
			}

			public void remove() {
				throw new UnsupportedOperationException();
			}

			private long next(long source) {
				long param1 = smallestBitOf(source);
				long param2 = param1 + source;
				long param3 = smallestBitOf(param2);
				long param5 = (param3 / param1) >>> 1;
				return param5 - 1 + param2;
			}

			private long smallestBitOf(long source) {
				long result = 1L;
				while (source % 2 == 0) {
					source >>>= 1;
					result <<= 1;
				}
				return result;
			}
		}
	}
}


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.text.DecimalFormat;
import java.util.StringTokenizer;

public class Main {

    static int N;
    static int K;
    static int A;
    static double dl[];
    static int base[];
    static int needed;
    static int b[] = new int[N];
    static int l[] = new int[N];

    static double best;

    static void printLevels() {
        int i;
        for (i=0;i<N;i++) {
            System.out.println(i+" "+dl[i]);
        }
    }

    static void giveCandies(int i, int remaining) {

        if (remaining == 0) {
            check();
            return;
        }

        if (i == N) {
            check();
            return;
        }

        int j;
        double ns;
        double orig = dl[i];

        for (j=0;j<=remaining;j++) {

            ns = orig+j*0.1;

            if (ns <= 1.0) {
                dl[i] = ns;
                giveCandies(i+1, remaining-j);
                dl[i] = orig;
            } else {
                break;
            }

        }

    }

    static void check() {
        int i,j,k;

        double res = 0.0;
        int total;
        double prob;
        int max = 1<<N;

        double sumg, sumb;
        double pk, da = (double)A;

        for (k=0;k<max;k++) {

            prob = 1.0;
            total = 0;

            sumg = 0;
            sumb = 0;

            for (i=0;i<N;i++) {
                if ((base[i]&k) > 0) {
                    prob *= dl[i];
                    total++;
                    sumg += b[i];

                } else {
                    prob *= (1.0-dl[i]);
                    sumb += b[i];

                }
            }

            if (total >= needed) {
                // needed number of senators voted positivelly
                res += prob;
            } else {
                pk = da/(da+sumb);

                res += prob*pk;

            }

        }

        best = Math.max(best, res);

    }

    public static void main(String[] args) throws Exception {
        int i,j,k;

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        N = Integer.parseInt(st.nextToken());
        K = Integer.parseInt(st.nextToken());
        A = Integer.parseInt(st.nextToken());

        needed = N/2+1;

        b = new int[N];
        l = new int[N];
        dl = new double[N];

        for (i=0;i<N;i++) {

            st = new StringTokenizer(br.readLine());
            b[i] = Integer.parseInt(st.nextToken());
            l[i] = Integer.parseInt(st.nextToken());
            dl[i] = ((double)l[i])/100.0;

        }

        base = new int[8];
        base[0] = 1;
        for (i=1;i<N;i++) {
            base[i] = base[i-1]*2;
        }

        best = 0.0;

        giveCandies(0, K);

        DecimalFormat df = new DecimalFormat("0.0000000000");

        String rs = df.format(best);
        String mrs = "";

        for (i=0;i<rs.length();i++) {
            if (rs.charAt(i) == ',') {
                mrs += '.';
            } else {
                mrs += rs.charAt(i);
            }
        }

        System.out.println(mrs);

    }

}


import java.awt.Point;
import java.util.Scanner;

public class p105b {
    static int[] b, l;
    static int n;
    static int A;
    static boolean[] masks;
    static double max;

    public static double work(int index, int k, int mask) {
        if (index == n) {
            if (Integer.bitCount(mask) * 2 <= n) {
                int sum = 0;
                for (int i = 0; i < n; i++) {
                    if (((1 << i) & mask) == 0) {
                        sum += b[i];
                    }
                }
                return (A * 1.0) / (A * 1.0 + sum);
            }
            return 1;
        }
        double max = 0;
        int to = Math.min(k, (100 - l[index]) / 10);

        for (int i = to; i >= 0; i--) {
            double loy = l[index] + i * 10;

            double b = ((100.0 - loy) / 100.0) * work(index + 1, k - i, mask);

            double a = (loy / 100.0)
                    * work(index + 1, k - i, (mask | (1 << index)));

            max = Math.max(max, a + b);
        }
        return max;
    }

    public static void rec(int index, int k) {
        if (k == -1)
            return;
        if (index == n) {
            double tot = 0;
            for (int i = 0; i < 1 << n; i++) {
                double temp = 1.0;
                int bb = 0;
                for (int j = 0; j < n; j++) {
                    if(l[j]>100)
                        return;
                    if (((1 << j) & i) != 0) {
                        temp *= (l[j] * 1.0 / 100.0);
                    } else {
                        bb += b[j];
                        temp *= ((100.0 - l[j]) / 100.0);
                    }
                }
                if (Integer.bitCount(i) * 2 <= n) {
                    temp *= (A * 1.0) / (A * 1.0 + bb);
                }
                tot += temp;
            }
            max = Math.max(max, tot);
            return;
        }
        l[index] += 10;
        rec(index, k - 1);
        l[index] -= 10;
        rec(index + 1, k);
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        int k = in.nextInt();

        A = in.nextInt();

        b = new int[n];
        l = new int[n];
        for (int i = 0; i < n; i++) {
            b[i] = in.nextInt();
            l[i] = in.nextInt();
        }
        masks = new boolean[1 << n];

        max = 0;
        rec(0, k);
        System.out.println(max);
    }
}

/*
 * 5 3 100 23 70 80 30 153 70 11 80 14 90
 */


import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author pttrung
 */
public class B {

    static Senator[] data;

    public static void main(String[] args) {
        Scanner in = new Scanner(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        int n = in.nextInt();
        int k = in.nextInt();
        int A = in.nextInt();
        data = new Senator[n];
        for (int i = 0; i < n; i++) {
            data[i] = new Senator(in.nextInt(), in.nextInt());
        }
        out.println(cal(0, new int[n], A, k));

        out.close();
    }

    public static double cal(int index, int[] num, int A, int left) {
        if (index == data.length - 1) {
            int dif = (100 - data[index].loyal)/10;
            dif = left >= dif? dif:left;
            num[index] =  dif;

            double result = 0;
            for (int k = 0; k < (1 << num.length); k++) {
                double val = 1;
                double total = 0;
                for (int i = 0; i < num.length; i++) {
                    if (((1 << i) & k) != 0) {
                        val *= ((double)(data[i].loyal + 10*num[i])/100);
                    } else {
                        val *= ((double)(100 - (data[i].loyal + 10*num[i]))/100);
                        total += data[i].level;
                    }
                }
                if (countBit(k) > num.length / 2) {
                    result += val;
                } else {
                    result += val * ((double) A / (A + total));
                }
            }
//           // if(result >= 1){
//                for(int i : num){
//                    System.out.print(i + " ");
//                }
//                System.out.println("\n" + result);
//            //}
            return result;
        } else {
            double result = 0;
            for (int i = 0; i <= left; i++) {
                if (i * 10 + data[index].loyal <= 100) {
                    num[index] = i;
                  //  double val = cal(index + 1 , num , A, left - i);

                    result = Math.max(result, cal(index + 1, num, A, left - i));
                } else {
                    break;
                }
            }
            return result;
        }
    }

    public static int countBit(int val) {
        int result = 0;
        while (val > 0) {
            result += val % 2;
            val >>= 1;
        }
        return result;
    }

    public static class Senator {

        int level, loyal;

        public Senator(int level, int loyal) {
            this.level = level;
            this.loyal = loyal;
        }
    }

    public static boolean nextPer(int[] data) {
        int i = data.length - 1;
        while (i > 0 && data[i] < data[i - 1]) {
            i--;
        }
        if (i == 0) {
            return false;
        }
        int j = data.length - 1;
        while (data[j] < data[i - 1]) {
            j--;
        }
        int temp = data[i - 1];
        data[i - 1] = data[j];
        data[j] = temp;
        Arrays.sort(data, i, data.length);
        return true;
    }

    public static class Point {

        int x, y, z;

        public Point(int x, int y, int z) {
            this.x = x;
            this.y = y;
            this.z = z;
        }
    }

    public double pow(double a, int b) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        double val = pow(a, b / 2);
        if (b % 2 == 0) {
            return val * val;
        } else {
            return val * val * a;
        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long lcm(long a, long b) {
        return a * b / gcd(a, b);
    }
}


/**
 * Created by IntelliJ IDEA.
 * User: Taras_Brzezinsky
 * Date: 8/13/11
 * Time: 6:10 PM
 * To change this template use File | Settings | File Templates.
 */

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
import java.io.IOException;

public class DarkAssembly extends Thread {

    public DarkAssembly() {
        this.input = new BufferedReader(new InputStreamReader(System.in));
        this.output = new PrintWriter(System.out);
        this.setPriority(Thread.MAX_PRIORITY);
    }

    class Senator {
        int loyalty;
        int level;

        public Senator(int level, int loyalty) {
            this.level = level;
            this.loyalty = loyalty;
        }
    }

    private static double doIt(Senator[] senators, int A) {
        double probability = .0;
        for (int mask = 0; mask < (1 << senators.length); ++mask) {
            int sum = A;
            double current = 1.0;
            for (int i = 0; i < senators.length; ++i) {
                if ((mask & (1 << i)) != 0) {
                    current *= .01 * Math.min(senators[i].loyalty, 100);
                } else {
                    current *= .01 * (100 - Math.min(senators[i].loyalty, 100));
                    sum += senators[i].level;
                }
            }
            if (getOnes(mask) > senators.length / 2) {
                probability += current;
            } else {
                probability += current * (double)A / sum;
            }
        }
        return probability;
    }

    private static double go(Senator []senators, int candies, int A, int current) {
        if (current == senators.length) {
            return doIt(senators, A);
        } else {
            double result = Double.MIN_VALUE;
            if (candies > 0) {
                senators[current].loyalty += 10;
                result = Math.max(result, go(senators, candies - 1, A, current));
                senators[current].loyalty -= 10;
            }
            result = Math.max(result, go(senators, candies, A, current + 1));
            return result;
        }
    }

    static int getOnes(int mask) {
        int result = 0;
        while (mask != 0) {
            mask &= mask - 1;
            ++result;
        }
        return result;
    }

    public void run() {
        try {
            int n = nextInt();
            int k = nextInt();
            int A = nextInt();
            Senator[] senators = new Senator[n];
            for (int i = 0; i < n; ++i) {
                senators[i] = new Senator(nextInt(), nextInt());
            }
            output.printf("%.10f", go(senators, k, A, 0));

            output.flush();
            output.close();

        } catch (Throwable e) {
            System.err.println(e.getMessage());
            System.err.println(Arrays.deepToString(e.getStackTrace()));
        }
    }

    public static void main(String[] args) {
        new DarkAssembly().start();
    }

    private String nextToken() throws IOException {
        while (tokens == null || !tokens.hasMoreTokens()) {
            tokens = new StringTokenizer(input.readLine());
        }
        return tokens.nextToken();
    }

    private int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    private double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    private long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    private BufferedReader input;
    private PrintWriter output;
    private StringTokenizer tokens = null;
}


import java.io.*;

import java.awt.geom.Point2D;
import java.text.*;
import java.math.*;
import java.util.*;

public class Main implements Runnable {

	final String filename = "";

	public int nextPerm(int[] a, int k) {
		if (a[0] == k)
			return -1;
		int last = 0;
		for (int i = a.length - 1; i >= 0; i--)
			if (a[i] != 0) {
				last = i;
				break;
			}
		int mem=a[last];
		a[last-1]++;
		a[last]=0;
		a[a.length-1]=mem-1;
		return 0;
	}

	public double poss(int A,int[][] sen,int[] rasp){
		int n=sen.length;
		double[] possluck=new double[n];
		for(int i=0;i<n;i++)
			possluck[i]=Math.min(100, sen[i][1]+rasp[i]*10)/100.0;
		double poss=0;
		for(int i=0;i<(1<<n);i++){
			int kol=0;
			for(int j=0;j<n;j++)
				if((i%(1<<(j+1)))/(1<<(j))==1)
					kol++;
			double thisposs=1;
			for(int j=0;j<n;j++)
				if((i%(1<<(j+1)))/(1<<(j))==1)
					thisposs*=possluck[j];
				else
					thisposs*=(1-possluck[j]);
			if(kol>n/2)
				poss+=thisposs;
			else{
				double lvl=0;
				for(int j=0;j<n;j++)
					if((i%(1<<(j+1)))/(1<<(j))==0)
						lvl+=sen[j][0];
				poss+=thisposs*(A/(A+lvl));
			}
		}
		return poss;
	}

	public void solve() throws Exception {
		int n = iread(), k = iread(), A = iread();
		int[][] sen = new int[n][2];
		for (int i = 0; i < n; i++) {
			sen[i][0] = iread();
			sen[i][1] = iread();
		}
		double maxposs=0;
		int[] rasp=new int[n];
		rasp[n-1]=k;
		maxposs=Math.max(maxposs, poss(A,sen,rasp));
		while(nextPerm(rasp,k)==0)
			maxposs=Math.max(maxposs, poss(A,sen,rasp));
		out.write(maxposs+"\n");
	}

	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new BufferedWriter(new OutputStreamWriter(System.out));
			// in = new BufferedReader(new FileReader(filename+".in"));
			// out = new BufferedWriter(new FileWriter(filename+".out"));
			solve();
			out.flush();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	public int iread() throws Exception {
		return Integer.parseInt(readword());
	}

	public double dread() throws Exception {
		return Double.parseDouble(readword());
	}

	public long lread() throws Exception {
		return Long.parseLong(readword());
	}

	BufferedReader in;

	BufferedWriter out;

	public String readword() throws IOException {
		StringBuilder b = new StringBuilder();
		int c;
		c = in.read();
		while (c >= 0 && c <= ' ')
			c = in.read();
		if (c < 0)
			return "";
		while (c > ' ') {
			b.append((char) c);
			c = in.read();
		}
		return b.toString();
	}

	public static void main(String[] args) {
		try {
			Locale.setDefault(Locale.US);
		} catch (Exception e) {

		}
		// new Thread(new Main()).start();
		new Thread(null, new Main(), "1", 1 << 25).start();
	}
}


import java.io.BufferedReader;
import java.util.Comparator;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Collection;
import java.util.List;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.util.Collections;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author AlexFetisov
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskB solver = new TaskB();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskB {

    private double[][][] dp;
    private int n;
    private int k;
    private int[] loyalty;
    private int[] level;
    double[] P;
    private int a;

    public void solve(int testNumber, InputReader in, PrintWriter out) {
        n = in.nextInt();
        k = in.nextInt();
        a = in.nextInt();
        level = new int[n];
        loyalty = new int[n];
        for (int i = 0; i < n; ++i) {
            level[i] = in.nextInt();
            loyalty[i] = in.nextInt();
        }

        P = new double[1 << n];
        for (int mask = 0; mask < (1 << n); ++mask) {
            if (Integer.bitCount(mask) * 2 > n) {
                P[mask] = 1.;
            } else {
                double sumB = 0;
                for (int i = 0; i < n; ++i) {
                    if (!BitUtils.checkBit(mask, i)) {
                        sumB += level[i];
                    }
                }
                P[mask] = (double)a / (sumB + a);
            }
        }

        dp = new double[1 << n][n + 1][k + 1];
        ArrayUtils.fill(dp, -1);
        newLoyalty = new int[n];
        //double res = rec(0, 0, k, 0);
        brute(0, k);
        out.println(best);
    }

    int[] newLoyalty;
    double best = 0;

    void brute(int id, int leftCandies) {
        if (id == n) {
            double cur = calcCur();
            if (best < cur) {
                best = cur;
            }
            return;
        }
        for (int candies = 0; candies <= leftCandies; ++candies) {
            newLoyalty[id] = loyalty[id] + candies * 10;
            if (newLoyalty[id] > 100) {
                break;
            }
            brute(id + 1, leftCandies - candies);
        }
    }

    private double calcCur() {
        double sum = 0;
        for (int mask = 0; mask < (1 << n); ++mask) {
            double p = getP(mask) * P[mask];
            sum += p;
        }
        return sum;
    }

    private double getP(int mask) {
        double p = 1;
        for (int i = 0; i < n; ++i) {
            if (BitUtils.checkBit(mask, i)) {
                p *= (newLoyalty[i] * 1.) / 100.;
            } else {
                p *= (100. - newLoyalty[i]) / 100.;
            }
        }
        return p;
    }

}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer stt;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
    }

    public String nextLine() {
        try {
            return reader.readLine().trim();
        } catch (IOException e) {
            return null;
        }
    }

    public String nextString() {
        while (stt == null || !stt.hasMoreTokens()) {
            stt = new StringTokenizer(nextLine());
        }
        return stt.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(nextString());
    }

}

class BitUtils {
    public static boolean checkBit(int mask, int bit) {
        return (mask & (1 << bit)) > 0;
    }

}

class ArrayUtils {

    public static void fill(double[][][] f, double value) {
        for (int i = 0; i < f.length; ++i) {
            for (int j = 0; j < f[i].length; ++j) {
                Arrays.fill(f[i][j], value);
            }
        }
    }

}


import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.io.InputStream;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.IOException;
import java.util.InputMismatchException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.OutputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Alex
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(1, in, out);
        out.close();
    }
    static class TaskB {
        double special(int[] loyalties, int[] levels, int playerlevelsum) {
            int poss = 1 << loyalties.length;
            double res = 0;
            for(int pos = 0; pos < poss; pos++) {
                double occurs = 1;
                int happy = 0;
                int badlevelssum = 0;
                for(int i = 0; i < loyalties.length; i++) {
                    if(((pos >> i) & 1) == 1) { //happy senator
                        happy++;
                        occurs *= (double) loyalties[i] / 100;
                    } else { //unhappy senator
                        badlevelssum += levels[i];
                        occurs *= (double) (100 - loyalties[i]) / 100;
                    }
                }
                double winprob = (happy <= levels.length / 2) ? (double) playerlevelsum / (playerlevelsum + badlevelssum) :
                        1;
//            System.err.println(pos + " " + (happy <= levels.length / 2) + " " + playerlevelsum + " " + (playerlevelsum + badlevelssum) + " " + occurs + " " + winprob + " " + occurs * winprob);
                res += occurs * winprob;
            }
            return res;
        }

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int senators = in.readInt(); // n, [1, 8]
            int sweets = in.readInt(); // k, [1, 8]
            int playerlevelsum = in.readInt(); // A, [1, 9999]
            int[] levels = new int[senators]; // [1, 9999]
            int[] loyalties = new int[senators]; // [0, 100] divisible by 10
            IOUtils.readIntArrays(in, levels, loyalties);
            ArrayList<ArrayList<Integer>> possibilities = new ArrayList<>(Arrays.asList(new ArrayList<>()));
            for(int senator = 0; senator < senators; senator++) {
                ArrayList<ArrayList<Integer>> newpossibilities = new ArrayList<>();
                for(ArrayList<Integer> al : possibilities) {
                    int sumsofar = 0;
                    for(int val : al) sumsofar += val;
                    int minadd = senator == senators - 1 ? sweets - sumsofar : 0;
                    for(int moar = minadd; moar <= sweets - sumsofar; moar++) {
                        ArrayList<Integer> copy = new ArrayList<>(al);
                        copy.add(moar);
                        newpossibilities.add(copy);
                    }
                }
                possibilities = newpossibilities;
            }
            double res = 0;
//        out.printLine(possibilities.size());
            for(ArrayList<Integer> al : possibilities) {
                int[] newloyalties = new int[senators];
                for(int i = 0; i < senators; i++) newloyalties[i] = Math.min(100, loyalties[i] + 10 * al.get(i));
//            out.printLine(al);
//            out.printLine(newloyalties);
//            double works = dp(0, 0, newloyalties);
                double special = special(newloyalties, levels, playerlevelsum);
                double tot = special;
                res = Math.max(res, tot);
            }
            out.printLine(res);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if(numChars == -1)
                throw new InputMismatchException();
            if(curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch(IOException e) {
                    throw new InputMismatchException();
                }
                if(numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while(isSpaceChar(c))
                c = read();
            int sgn = 1;
            if(c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if(c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while(!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if(filter != null)
                return filter.isSpaceChar(c);
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for(int i = 0; i < objects.length; i++) {
                if(i != 0)
                    writer.print(' ');
                writer.print(objects[i]);
            }
        }

        public void printLine(Object... objects) {
            print(objects);
            writer.println();
        }

        public void close() {
            writer.close();
        }

    }

    static class IOUtils {
        public static void readIntArrays(InputReader in, int[]... arrays) {
            for(int i = 0; i < arrays[0].length; i++) {
                for(int j = 0; j < arrays.length; j++)
                    arrays[j][i] = in.readInt();
            }
        }

    }
}


import java.util.*;
import java.math.*;
import static java.lang.Character.isDigit;
import static java.lang.Character.isLowerCase;
import static java.lang.Character.isUpperCase;
import static java.lang.Math.*;
import static java.math.BigInteger.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Character.isDigit;

public class Main{
    static void debug(Object...os){
        System.err.println(deepToString(os));
    }
    int n,A;
    int[] bs,ls;
    void run(){
        n=nextInt();int k=nextInt();A=nextInt();
        bs=new int[n];ls=new int[n];
        for(int i=0;i<n;i++) {
            bs[i]=nextInt();ls[i]=nextInt();
        }
        dfs(k,0);
        System.out.println(res);
    }

    double res=0;
    private void dfs(int k,int i){
        if(i==n) {
            double val=0;
            for(int j=0;j<1<<n;j++) {// 1 approve
                double p=1;
                int B=0;
                for(int l=0;l<n;l++)p*= (j>>l&1)==1 ? ls[l]/100.0 : (100-ls[l])/100.0;
                for(int l=0;l<n;l++)if((j>>l&1)==0)B += bs[l];
                if(Integer.bitCount(j) > n/2) {
                    val += p;
                }else {
                    val += p * A / (A+B);
                }
            }
            res=max(res,val);
            return;
        }
        for(int j=0;j<k+1;j++) {
            ls[i]+=j*10;
            if(ls[i]<=100) {
                dfs(k-j,i+1);
            }
            ls[i]-=j*10;
        }
    }

    int nextInt(){
        try{
            int c=System.in.read();
            if(c==-1) return c;
            while(c!='-'&&(c<'0'||'9'<c)){
                c=System.in.read();
                if(c==-1) return c;
            }
            if(c=='-') return -nextInt();
            int res=0;
            do{
                res*=10;
                res+=c-'0';
                c=System.in.read();
            }while('0'<=c&&c<='9');
            return res;
        }catch(Exception e){
            return -1;
        }
    }

    long nextLong(){
        try{
            int c=System.in.read();
            if(c==-1) return -1;
            while(c!='-'&&(c<'0'||'9'<c)){
                c=System.in.read();
                if(c==-1) return -1;
            }
            if(c=='-') return -nextLong();
            long res=0;
            do{
                res*=10;
                res+=c-'0';
                c=System.in.read();
            }while('0'<=c&&c<='9');
            return res;
        }catch(Exception e){
            return -1;
        }
    }

    double nextDouble(){
        return Double.parseDouble(next());
    }

    String next(){
        try{
            StringBuilder res=new StringBuilder("");
            int c=System.in.read();
            while(Character.isWhitespace(c))
                c=System.in.read();
            do{
                res.append((char)c);
            }while(!Character.isWhitespace(c=System.in.read()));
            return res.toString();
        }catch(Exception e){
            return null;
        }
    }

    String nextLine(){
        try{
            StringBuilder res=new StringBuilder("");
            int c=System.in.read();
            while(c=='\r'||c=='\n')
                c=System.in.read();
            do{
                res.append((char)c);
                c=System.in.read();
            }while(c!='\r'&&c!='\n');
            return res.toString();
        }catch(Exception e){
            return null;
        }
    }
    public static void main(String[] args){
        new Main().run();
    }
}


import java.awt.*;
import java.awt.geom.*;
import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;
public class B {
	static int ourLevel;
	public static void main(String[] args) throws IOException	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		int n = Integer.parseInt(st.nextToken());
		int k = Integer.parseInt(st.nextToken());
		ourLevel = Integer.parseInt(st.nextToken());
		State[] list = new State[n];
		for(int i = 0; i < n; i++)	{
			st = new StringTokenizer(br.readLine());
			list[i] = new State(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken())/10);
		}
		System.out.println(solve(list, 0, k));
	}
	public static double solve(State[] s, int index, int left)		{
		if(index == s.length)
			return prob(s);
		double ret = 0;
		for(int c = 0; c <= left && s[index].prob + c <= 10; c++)	{
			s[index].prob += c;
			ret = Math.max(ret, solve(s, index+1, left-c));
			s[index].prob -= c;
		}
		return ret;
	}
	public static double prob(State[] s)	{
		double win = 1;
		for(int i = 0; i < (1<<s.length); i++)	{
			int numLose = s.length - Integer.bitCount(i);
			if(2*numLose >= s.length)	{
				int level = 0;
				double p = 1;
				for(int j = 0; j < s.length; j++)	{
					if((i&(1<<j)) == 0)	{
						p *= (10-s[j].prob)/10.;
						level += s[j].level;
					}
					else	{
						p *= s[j].prob/10.;
					}
				}
				double lose = level * 1.0 / (ourLevel + level);
				win -= p * lose;
			}
		}
		return win;
	}
	static class State	{
		public int level,prob;
		public State(int a, int b)	{
			level = a;
			prob = b;
		}
	}
}