use proconio::input;

const INF: i64 = 1_000_000_000_000_000_000;
const MOD: i64 = 998244353;

fn main() {
    input! {
        N: usize, W: i64,
        mut items: [(i64, i64); N],
    }
    items.sort_by_key(|p| p.1 );

    let mut dp = vec![(-INF, 0i64, false); 30000 as usize];
    dp[10000] = (0, 1, true);

    for (v, w) in items {
        if w > 0 {
            for w_sum in (0 .. dp.len() as i64).rev() {
                if (0 .. dp.len() as i64).contains(&(w_sum + w)) {
                    let (v_sum, count, exist) = dp[w_sum as usize];
                    if !exist {
                        continue;
                    }
                    let v_sum_next = v_sum + v;
                    let w_sum_next = (w_sum + w) as usize;
                    if dp[w_sum_next].0 < v_sum_next {
                        dp[w_sum_next] = (v_sum_next, count, true);
                    } else if dp[w_sum_next].0 == v_sum_next {
                        dp[w_sum_next].1 += count;
                        dp[w_sum_next].1 %= MOD;
                        dp[w_sum_next].2 = true;
                    }
                }
            }
        } else if w < 0 {
            for w_sum in 0 .. dp.len() as i64 {
                if (0 .. dp.len() as i64).contains(&(w_sum + w)) {
                    let (v_sum, count, exist) = dp[w_sum as usize];
                    if !exist {
                        continue;
                    }
                    let v_sum_next = v_sum + v;
                    let w_sum_next = (w_sum + w) as usize;
                    if dp[w_sum_next].0 < v_sum_next {
                        dp[w_sum_next] = (v_sum_next, count, exist);
                    } else if dp[w_sum_next].0 == v_sum_next {
                        dp[w_sum_next].1 += count;
                        dp[w_sum_next].1 %= MOD;
                        dp[w_sum_next].2 = true;
                    }
                }
            }
        } else if v > 0 {
            for x in &mut dp {
                x.0 += v;
            }
        }
    }

    let mut value_max = -INF;
    let mut count = 0;
    for i in 0 ..= (10000 + W) as usize {
        let (v, c, x) = dp[i];
        if x {
            if value_max < v {
                value_max = v;
                count = c;
            } else if value_max == v {
                count += c;
                count %= MOD;
            }
        }
    }
    println!("{value_max} {count}");
}