#include <cstdio>
#include <cstring>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cctype>

namespace uvu
{
#define LOCAL ____________DONT_DEFINE_ME____________
// #define ll long long
// #define inf 0x3f3f3f3f
#define int long long
#define inf 0x3f3f3f3f3f3f3f3fll
#define infll 0x3f3f3f3f3f3f3f3fll
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define gline debug("now is #%d\n", __LINE__)
#define pii std::pair <int, int>
#define mkp std::make_pair
#define fi first
#define se second
char _ST_;
const int BUFSIZE = (1 << 2);
char ibuf[BUFSIZE], *iS = ibuf, *iT = ibuf;
char obuf[BUFSIZE], *oS = obuf, *oT = obuf + BUFSIZE;
char getc()
{
#ifdef LOCAL
	return getchar();
#else
	if(iS == iT) iT = (iS = ibuf) + fread(ibuf, 1, BUFSIZE, stdin);
	return iS == iT ? EOF : *iS++;
#endif
#define getchar ERR
}

void Flush() { fwrite(obuf, 1, oS - obuf, stdout); oS = obuf; }
struct Flusher { ~Flusher(){ Flush(); } }iamflusher;

void putc(char c)
{
#ifdef LOCAL
	putchar(c);
#else
	*oS++ = c;
	if(oS == oT) Flush();
#endif
#define putchar ERR
}

template <typename T = int> T read()
{
	T x = 0, f = 1; char c = getc();
	for(; !isdigit(c); c = getc()) if(c == '-') f = -1;
	for(;  isdigit(c); c = getc()) x = (x << 3) + (x << 1) + (c ^ 48);
	return x * f;
}

template <typename T> void print(T x, char c)
{
static int sta[BUFSIZE], top;
	top = 0;
	if(x < 0) putc('-'), x = -x;
	if(!x) sta[top = 1] = 0;
	for(; x; x /= 10) sta[++top] = x % 10;
	for(; top; ) putc(sta[top--] ^ 48);
	if(c) putc(c);
}

int readstr(char *s, int base)
{
	int idx = base - 1; char c = getc();
	for(; !(isdigit(c) || isalpha(c) || c == '#' || c == '.'); c = getc());
	for(;   isdigit(c) || isalpha(c) || c == '#' || c == '.' ; c = getc()) s[++idx] = c;
	return idx - base + 1;
}

void printf(const char *s) { for(; *s; s++) putc(*s); }
template <typename T, typename ... Args>
void printf(const char *s, T x, Args ... rest)
{
	for(; *s; s++)
	{
		if(*s != '%') { putc(*s); continue; }
		s++; if(*s == 'd') print(x, 0);
		else if(*s == 'c') putc(x);
		printf(s + 1, rest ...);
		return;
	}
}

template <typename T> void ckmax(T &x, T y) { x = x > y ? x : y; }
template <typename T> void ckmin(T &x, T y) { x = x < y ? x : y; }
#define mod 998244353
// #define mod 1000000007
int sm(int x) { return x >= mod ? x - mod : x; }
void plus_(int &x, int y) { x = sm(x + y); }
void mul_(int &x, int y) { x = 1ll * x * y % mod; }
int ksm(int a, int b) { int res = 1; for(; b; b >>= 1, mul_(a, a)) if(b & 1) mul_(res, a); return res; }

#define N 10010
int n, m, K;
int w_[N], _w[N];
signed v_[N], _v[N];
int p[N];
int sta[N], top, d;
int R[N], L[N];
signed dp[2][N][21];
int op;

void solve()
{
	// memset(h, idx = -1, sizeof(h));
    n = read(), m = read(), K = read();
    for(int i = 1; i <= n; i++) _v[i] = read(), _w[i] = read();
    std::iota(p + 1, p + 1 + n, 1); std::sort(p + 1, p + 1 + n, [&](int x, int y) -> bool { return 1ll * _w[x] * _v[y] > 1ll * _w[y] * _v[x]; });
	for(int i = 1; i <= n; i++) v_[i] = _v[p[i]], w_[i] = _w[p[i]];
	d = *std::max_element(v_ + 1, v_ + 1 + n);

	{
		int tot = 0, sum = 0;
		for(int i = 1; i <= n; i++)
		{
			for(int j = std::max(m - d, tot); j <= std::min(m + d, tot + v_[i]); j++)
			{
				// L[j - (m - d)] = sum;
				// R[j - (m - d)] = sum + w_[i];
				R[j - (m - d)] = sum + (j - tot) * w_[i] / v_[i];
				L[j - (m - d)] = R[j - (m - d)] - K;
				// printf("L[%d] = %d, R[%d] = %d (i = %d)\n", j, L[j - (m - d)], j, R[j - (m - d)], i);
			}
			tot += v_[i], sum += w_[i];
		}
	}
	int p = 0, tot = 0, sum = 0;
	for(; p < n && tot < m - d; ++p, tot += v_[p], sum += w_[p]);
	if(p == n) { print(sum, '\n'); return; }
	dp[op = 0][tot - (m - d)][sum - L[tot - (m - d)]] = p + 1;
	// for(int i = 1; i <= n; i++) printf("[%d %d] ", v_[i], w_[i]); putc('\n');
	// printf("p = %d, tot = %d, sum = %d (m = %d, d = %d)\n", p, tot, sum, m, d);
   int i, x, y, k;
	for(i = p + 1; i <= n; i++)
	{
		op ^= 1;
		for(x = m - d; x <= m + d; x++) for(y = L[x - (m - d)]; y <= R[x - (m - d)]; y++) if(dp[op ^ 1][x - (m - d)][y - L[x - (m - d)]])
			ckmax(dp[op][x - (m - d)][y - L[x - (m - d)]], dp[op ^ 1][x - (m - d)][y - L[x - (m - d)]]);
		for(x = m - d; x <= m; x++) for(y = L[x - (m - d)]; y <= R[x - (m - d)]; y++) 
			if(dp[op ^ 1][x - (m - d)][y - L[x - (m - d)]] && L[x + v_[i] - (m - d)] <= y + w_[i] && y + w_[i] <= R[x + v_[i] - (m - d)])
				ckmax(dp[op][x + v_[i] - (m - d)][y + w_[i] - L[x + v_[i] - (m - d)]], dp[op ^ 1][x - (m - d)][y - L[x - (m - d)]]);
		for(x = m + d; x >= m; x--) for(y = L[x - (m - d)]; y <= R[x - (m - d)]; y++)
		{
			for(k = std::max(1, dp[op ^ 1][x - (m - d)][y - L[x - (m - d)]]); k < dp[op][x - (m - d)][y - L[x - (m - d)]]; k++)
			{
				if(x >= v_[k] && L[x - v_[k] - (m - d)] <= y - w_[k] && y - w_[k] <= R[x - v_[k] - (m - d)])
					ckmax(dp[op][x - v_[k] - (m - d)][y - w_[k] - L[x - v_[k] - (m - d)]], (signed)k);
			}
		}
		for(x = m - d; x <= m + d; x++) for(y = L[x - (m - d)]; y <= R[x - (m - d)]; y++) dp[op ^ 1][x - (m - d)][y - L[x - (m - d)]] = 0;
	}
	int ans = 0;
	for(x = m - d; x <= m; x++) for(y = L[x - (m - d)]; y <= R[x - (m - d)]; y++) if(dp[op][x - (m - d)][y - L[x - (m - d)]])
		ckmax(ans, y);
	print(ans, '\n');
}

void init()
{

}

char _ED_;

void mian()
{
	debug("%.3f MB\n", abs(&_ST_ - &_ED_) / 1024.0 / 1024);
	init();
	for(int T = 1; T; solve(), T--);
}

#ifdef int
	#undef int
#endif
}

int main()
{
	// freopen("tmp.in", "r", stdin);
	// freopen("tmp.out", "w", stdout);
	uvu::mian(); return 0;
}