package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"sort"
)

type Problem struct {
	a int
	p int
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var tc int
	if _, err := fmt.Fscan(in, &tc); err != nil {
		return
	}

	for t := 0; t < tc; t++ {
		var n int
		fmt.Fscan(in, &n)
		var C, T float64
		fmt.Fscan(in, &C, &T)

		probs := make([]Problem, n)
		maxTotalScore := 0
		for i := 0; i < n; i++ {
			fmt.Fscan(in, &probs[i].a, &probs[i].p)
			maxTotalScore += probs[i].p
		}

		sort.Slice(probs, func(i, j int) bool {
			return probs[i].a > probs[j].a
		})

		dp := make([][]float64, n+1)
		for i := range dp {
			dp[i] = make([]float64, maxTotalScore+1)
			for j := range dp[i] {
				dp[i][j] = math.Inf(1)
			}
		}
		dp[0][0] = 0.0

		invPow := make([]float64, n+1)
		invPow[0] = 1.0
		for i := 1; i <= n; i++ {
			invPow[i] = invPow[i-1] / 0.9
		}

		maxK := 0
		maxV := 0
		for _, prob := range probs {
			for k := maxK; k >= 0; k-- {
				for v := maxV; v >= 0; v-- {
					if dp[k][v] != math.Inf(1) {
						newW := dp[k][v] + float64(prob.a)*invPow[k+1]
						if newW < dp[k+1][v+prob.p] {
							dp[k+1][v+prob.p] = newW
						}
					}
				}
			}
			maxK++
			maxV += prob.p
		}

		ans := 0
		for k := 0; k <= n; k++ {
			for v := 0; v <= maxTotalScore; v++ {
				if dp[k][v] != math.Inf(1) {
					W := dp[k][v]
					var minTime float64
					if W*C > 1.0 {
						minTime = float64(10*k) + (2.0*math.Sqrt(W*C)-1.0)/C
					} else {
						minTime = float64(10*k) + W
					}
					if minTime <= T {
						if v > ans {
							ans = v
						}
					}
				}
			}
		}
		fmt.Fprintln(out, ans)
	}
}