Dark Assembly is a governing body in the Netherworld. Here sit the senators who take the most important decisions for the player. For example, to expand the range of the shop or to improve certain characteristics of the character the Dark Assembly's approval is needed.

The Dark Assembly consists of *n* senators. Each of them is characterized by his level and loyalty to the player. The level is a positive integer which reflects a senator's strength. Loyalty is the probability of a positive decision in the voting, which is measured as a percentage with precision of up to 10%. 

Senators make decisions by voting. Each of them makes a positive or negative decision in accordance with their loyalty. If strictly more than half of the senators take a positive decision, the player's proposal is approved. 

If the player's proposal is not approved after the voting, then the player may appeal against the decision of the Dark Assembly. To do that, player needs to kill all the senators that voted against (there's nothing wrong in killing senators, they will resurrect later and will treat the player even worse). The probability that a player will be able to kill a certain group of senators is equal to *A* / (*A* + *B*), where *A* is the sum of levels of all player's characters and *B* is the sum of levels of all senators in this group. If the player kills all undesired senators, then his proposal is approved.

Senators are very fond of sweets. They can be bribed by giving them candies. For each received candy a senator increases his loyalty to the player by 10%. It's worth to mention that loyalty cannot exceed 100%. The player can take no more than *k* sweets to the courtroom. Candies should be given to the senators before the start of voting.

Determine the probability that the Dark Assembly approves the player's proposal if the candies are distributed among the senators in the optimal way.
The first line contains three integers *n*, *k* and *A* (1 ≤ *n*, *k* ≤ 8, 1 ≤ *A* ≤ 9999).

Then *n* lines follow. The *i*-th of them contains two numbers — *b*<sub class="lower-index">*i*</sub> and *l*<sub class="lower-index">*i*</sub> — the *i*-th senator's level and his loyalty.

The levels of all senators are integers in range from 1 to 9999 (inclusive). The loyalties of all senators are integers in range from 0 to 100 (inclusive) and all of them are divisible by 10.
5 6 100
11 80
14 90
23 70
80 30
153 70
1.0000000000
5 3 100
11 80
14 90
23 70
80 30
153 70
0.9628442962
1 3 20
20 20
0.7500000000
4 3 40
10 40
11 50
10 50
9 50
0.7721162701
4 4 60
10 40
11 50
10 50
12 30
0.8031237097
2 7 20
10 40
10 50
0.8733333333
2 1 25
10 40
12 50
0.7329105397
3 3 31
10 40
12 50
15 0
0.6940741814
1 3 40
10 0
0.8600000000
1 4 30
10 20
0.9000000000
1 7 10
40 40
1.0000000000
1 8 1
1000 100
1.0000000000
1 1 1
9999 0
0.1000900000
1 1 9999
1 0
0.9999100000
2 4 345
323 40
234 20
0.6289385114
2 7 43
3435 90
6443 0
0.6327854764
8 8 10
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
0.5829886291
5 5 1000
2 90
5 60
13 70
80 30
1024 70
0.9950914339
8 8 1
6776 80
2346 70
7890 30
4567 90
9032 30
8092 80
1567 90
5678 80
1.0000000000
8 1 1
9999 0
9999 0
9999 0
9999 0
9999 0
9999 0
9999 0
9999 0
0.0000126797
8 1 9999
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
0.9992105456
8 8 686
654 100
15 100
954 100
14 100
9601 100
986 100
236 100
1 100
1.0000000000
8 8 9999
9999 0
9999 0
9999 0
9999 0
9999 0
9999 0
9999 0
9999 0
0.1237784500
8 8 1
1 90
2 0
3 80
4 0
5 80
6 0
7 80
8 90
1.0000000000
8 7 1
1 90
2 0
3 80
4 0
5 80
6 0
7 80
8 90
0.9071428571
8 7 1
1 90
2 70
3 80
4 10
5 80
6 50
7 80
8 90
0.9874642857
8 8 1
1 90
2 50
3 80
4 70
5 80
6 70
7 80
8 90
1.0000000000
1 1 2910
1 80
0.9999656475
1 2 240
5 20
0.9877551020
1 3 734
3 0
0.9971506106
2 1 7316
3 0
8 20
0.9988261248
2 2 843
2 30
3 20
0.9962225651
3 1 4887
5 60
9 80
6 40
0.9992612205
3 2 1446
8 60
3 0
2 50
0.9969756430
2 8 2218
2 10
1 40
0.9996395665
5 3 128
15 50
19 0
17 20
12 20
17 10
0.7071002446
8 8 2899
3701 20
5168 80
7885 60
4696 80
1798 90
7545 80
5414 80
4851 30
0.9806726602
8 7 2965
593 60
2963 20
4016 60
3076 100
780 0
8207 40
6093 0
6609 50
0.4380079393
8 6 4614
7484 90
758 70
146 80
1455 100
1344 50
7286 90
6773 50
8366 70
0.9950379538
8 5 4680
4376 20
8552 30
6276 0
9834 0
327 70
7948 50
7452 100
8542 100
0.4717698635
8 4 6328
1268 50
6348 80
2406 20
8214 0
9308 90
7027 10
8132 20
300 10
0.3102731277
8 3 6395
8159 90
4143 50
6954 50
5011 20
9872 10
7689 90
8811 70
2058 10
0.5175644027
8 2 6461
5051 10
1938 100
3084 70
3391 40
8854 30
6769 30
1073 0
3815 40
0.3586379660
8 1 8109
1944 40
9732 40
9214 80
1770 40
7837 50
7430 100
1753 30
3991 60
0.6441514424
import itertools as it

def powerset(iterable):
    "powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)"
    s = list(iterable)
    return it.chain.from_iterable(it.combinations(s, r) \
                                  for r in range(len(s)+1))


n, k, A = map(int, input().split())

best_result = 0

missing = 0

senators = []
for _ in range(n):
    level, loyality = map(int, input().split())
    senators += [[level, loyality]]
    missing += 10 - loyality // 10

k = min([k, missing]) # no need for too many candies

for comb in it.combinations_with_replacement(range(n), k):
    candies = [0] * n
    for senator, amount in [(x, len(list(y))) for x, y in it.groupby(comb)]:
        candies[senator] = amount
    overflow = False
    for senator in range(n):
        if candies[senator] * 10 + senators[senator][1] > 100:
            overflow = True
    if overflow:
        continue
    senators_tmp = [x[:] for x in senators]
    for senator in range(n):
        senators_tmp[senator][1] += candies[senator] * 10
    cresult = 0
    needed_to_win = n // 2 + 1
    for sub_set in powerset(range(n)):
        prob = 1
        bad_ones_str = 0
        for i in range(n):
            if i in sub_set:
                prob *= senators_tmp[i][1] / 100
            else:
                prob *= (100 - senators_tmp[i][1]) / 100
                bad_ones_str += senators_tmp[i][0]


        if len(sub_set) >= needed_to_win:
            cresult += prob
        else:
            cresult += prob * A / (A + bad_ones_str)

    if cresult > best_result:
        best_result = cresult

print(best_result)
