#include <bits/stdc++.h>
using namespace std;

namespace SOL {

using i64 = long long;
void debug(const char *msg, ...) {
#ifdef CLESIP
    va_list arg;
    static char pbString[512];
    va_start(arg,msg);
    vsprintf(pbString,msg,arg);
    cerr << "[DEBUG] " << pbString << "\n";
    va_end(arg);
#endif    
}
template<typename T, typename L>
bool chkmax(T &x, L y) { if (x < y) return x = y, true; return false; }
template<typename T, typename L>
bool chkmin(T &x, L y) { if (y < x) return x = y, true; return false; }

const int N = 22;
const i64 P = 998244353;
const i64 inf = 1e18;
int n, lim, sum[1 << N];
array<int, 2> a[N], tmp[1 << (N / 2 + 1)];

struct Node {
	i64 cost, cnt;
} f[1 << N], pre[1 << (N / 2 + 1)];

void mod(i64 &x, i64 y) {
	x += y;
	if (x >= P)
		x -= P;
}

void operator += (Node &lhs, const Node &rhs) {
	if (lhs.cost > rhs.cost) {
		lhs = rhs;
	} else if (lhs.cost == rhs.cost) {
		mod(lhs.cnt, rhs.cnt);
	}
}

Node add(const Node &o, int v) {
	return { o.cost + v, o.cnt };
}

void solve() {
	cin >> n >> lim;
	for (int i = 0; i < n; i ++)
		cin >> a[i][1] >> a[i][0];
	sort(a, a + n);
	for (int S = 1; S < (1 << n); S ++) {
		int k = __lg(S);
		sum[S] = sum[S - (1 << k)] + a[k][1];
		if (sum[S] > lim)
			sum[S] = lim + 1;
	}
	for (int S = 0; S < (1 << n); S ++)
		f[S] = { inf, 0 };
	f[0] = { 0, 1 };
	int n1 = (n + 1) / 2, n2 = n - n1;
	for (int S = 0; S + 1 < (1 << n); S ++) {
		int rem = ((1 << n) - 1) - S, T = S;
		int p = __lg(rem);
		T += (1 << p), rem -= (1 << p); 
		if (p < n1) {
			for (int nxt = rem; nxt; nxt = (nxt - 1) & rem)
				if (sum[T + nxt - S] <= lim)
					f[T + nxt] += add(f[S], a[p][0]);
			if (a[p][1] <= lim)
				f[T] += add(f[S], a[p][0]);
		} else {
			int tot = 0;
			int low = S & ((1 << n1) - 1), high = rem - (rem & ((1 << n1) - 1));
			for (int subset = low; subset; subset = (subset - 1) & low)
				tmp[++ tot] = { sum[low - subset], subset };
			tmp[++ tot] = { sum[low], 0 };
			sort(tmp + 1, tmp + 1 + tot);
			pre[0] = { inf, 0 };
			for (int i = 1; i <= tot; i ++) {
				pre[i] = pre[i - 1];
				pre[i] += f[tmp[i][1] + S - low];
			}
			
			for (int nxt = high; nxt >= 0; nxt = (nxt - 1) & high) if (sum[T + nxt - S] <= lim) {
				int pos = lower_bound(tmp + 1, tmp + 1 + tot, (array<int, 2>) { lim - sum[T + nxt - S] + 1, 0 }) - tmp - 1;
				// assert(pos + 1 > tot || tmp[pos + 1][0] > lim - sum[T + nxt - S]);
				f[nxt + T] += add(pre[pos], a[p][0]);
				if (nxt == 0)
					break;
			}
		}
	}
	auto ans = f[(1 << n) - 1];
	cout << ans.cost << " " << ans.cnt << "\n";
}

}
int main() {
	ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
	SOL::solve();
	return 0;
}