Problem:
Score : 400 points

Problem Statement

You have N items and a bag of strength W.
The i-th item has a weight of w_i and a value of v_i.

You will select some of the items and put them in the bag.
Here, the total weight of the selected items needs to be at most W.

Your objective is to maximize the total value of the selected items.

Constraints

1 ≤ N ≤ 100

1 ≤ W ≤ 10^9

1 ≤ w_i ≤ 10^9

For each i = 2,3,...,N, w_1 ≤ w_i ≤ w_1 + 3.

1 ≤ v_i ≤ 10^7

W, each w_i and v_i are integers.

Input

Input is given from Standard Input in the following format:

N W
w_1 v_1
w_2 v_2
:
w_N v_N

Output

Print the maximum possible total value of the selected items.

Sample Input 1

4 6
2 1
3 4
4 10
3 4

Sample Output 1

11

The first and third items should be selected.

Sample Input 2

4 6
2 1
3 7
4 10
3 6

Sample Output 2

13

The second and fourth items should be selected.

Sample Input 3

4 10
1 100
1 100
1 100
1 100

Sample Output 3

400

You can take everything.

Sample Input 4

4 1
10 100
10 100
10 100
10 100

Sample Output 4

0

You can take nothing.

Solution in Rust (1.15.1) (judge verdict: Accepted)

#[allow(unused_macros)]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}
 
#[allow(unused_macros)]
macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};
 
    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}
 
#[allow(unused_macros)]
macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };
 
    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };
 
    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };
 
    ($next:expr, bytes) => {
        read_value!($next, String).into_bytes()
    };
 
    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };
 
    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}
 
use std::cmp::Ordering;
 
/// Equivalent to std::lowerbound and std::upperbound in c++
pub trait BinarySearch<T> {
    fn lower_bound(&self, &T) -> usize;
    fn upper_bound(&self, &T) -> usize;
}
 
impl<T: Ord> BinarySearch<T> for [T] {
    fn lower_bound(&self, x: &T) -> usize {
        let mut low = 0;
        let mut high = self.len();
 
        while low != high {
            let mid = (low + high) / 2;
            match self[mid].cmp(x) {
                Ordering::Less => {
                    low = mid + 1;
                }
                Ordering::Equal | Ordering::Greater => {
                    high = mid;
                }
            }
        }
        low
    }
 
    fn upper_bound(&self, x: &T) -> usize {
        let mut low = 0;
        let mut high = self.len();
 
        while low != high {
            let mid = (low + high) / 2;
            match self[mid].cmp(x) {
                Ordering::Less | Ordering::Equal => {
                    low = mid + 1;
                }
                Ordering::Greater => {
                    high = mid;
                }
            }
        }
        low
    }
}
 
 
 
 
 
 
use std::cmp;
use std::cmp::min;
use std::collections::BTreeMap;
use std::process;
use std::cmp::Ord;
use std::collections::HashMap;
use std::collections::HashSet;
use std::collections::VecDeque;
use std::collections::BTreeSet;
use std::mem;
 
#[derive(PartialEq, Eq)]
pub struct point(i64, i64, i64);
impl Ord for point {
    fn cmp(&self, other: &point) -> Ordering {
        self.0.cmp(&other.0)
    }
}
 
impl PartialOrd for point {
    fn partial_cmp(&self, other: &point) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}
/*
impl PartialEq for point {
    fn eq(&self, other: &point) -> bool {
        self.0 == other.0
    }
}
impl Eq for point {
    fn eq(&self, other: &point) -> bool {
        self.0 == other.0
    }s
}*/
type P = (i64 , i64);
fn bfs(start:&P, goal:&P, map:&Vec<Vec<char>>) -> i64 {
        let dx = vec![1, 0, -1, 0];
        let dy = vec![0, 1, 0, -1];
        let s = (start.0, start.1);
        let g = (goal.0 , goal.1);
        let mut queue:VecDeque<P> = VecDeque::new();
        let mut d:Vec<Vec<i64>> = Vec::new();
        for i in 0..map.len(){
            d.push(Vec::new());
            for j in 0..map[i].len(){
                d[i].push(30000000);
            }
        }
        queue.push_back((s.0, s.1));
        d[s.0 as usize][s.1 as usize] = 0;
        while(queue.len()!=0){
            let mut p:P = queue[0];
            queue.pop_front();
            if p.0 == g.0 && p.1 == g.1{break;}
            for i in 0..4{
                let nx = p.0 + dx[i];
                let ny = p.1 + dy[i];
                if (0<=nx && nx <map.len() as i64 && 0<=ny &&ny<map[0].len() as i64 && map[nx as usize][ny as usize]!='#' && d[nx as usize][ny as usize] == 30000000 ){
                    queue.push_back((nx, ny));
                    d[nx as usize][ny as usize] = d[p.0 as usize][p.1 as usize] + 1;
                }
            }
 
        }
        d[goal.0 as usize][goal.1 as usize]
}
 
fn bfs01(start:&P, goal:&P, map:&Vec<Vec<char>>) -> i64 {
        let dx = vec![1, 0, -1, 0];
        let dy = vec![0, 1, 0, -1];
        let s = (start.0, start.1);
        let g = (goal.0 , goal.1);
        let mut queue:VecDeque<P> = VecDeque::new();
        let mut d:Vec<Vec<i64>> = Vec::new();
        for i in 0..map.len(){
            d.push(Vec::new());
            for j in 0..map[i].len(){
                d[i].push(30000000);
            }
        }
        queue.push_back((s.0, s.1));
        d[s.0 as usize][s.1 as usize] = 0;
        while(queue.len()!=0){
            let mut p:P = queue[0];
            queue.pop_front();
            if p.0 == g.0 && p.1 == g.1{break;}
            for i in 0..4{
                let nx = p.0 + dx[i];
                let ny = p.1 + dy[i];
                if (0<=nx && nx <map.len() as i64 && 0<=ny &&ny<map[0].len() as i64 && d[nx as usize][ny as usize] == 30000000 ){
                    if map[nx as usize][ny as usize] == '#'{
                        queue.push_back((nx, ny));
                        d[nx as usize][ny as usize] = d[p.0 as usize][p.1 as usize] + 1;
                    }
                    else{
                        queue.push_front((nx, ny));
                        d[nx as usize][ny as usize] = d[p.0 as usize][p.1 as usize];
                    }
                }
            }
 
        }
        d[goal.0 as usize][goal.1 as usize]
}
struct UnionFind_W{
    par:Vec<usize>,
    rank:Vec<usize>,
    size:Vec<usize>,
    diff_weight:Vec<i64>,    
}
impl UnionFind_W{
    fn init(n:usize) -> UnionFind_W{
        let mut par = vec![0;n];
        for i in 0..n{
            par[i] = i;    
        }
        UnionFind_W{
            par:par,
            rank:vec![0;n], 
            size:vec![1;n], 
            diff_weight:vec![0i64;n],
        }
    }
    fn find(&mut self, x:usize) ->usize{
        if(self.par[x] == x){
            x    
        }
        else{
            let p = self.par[x];
            let r = self.find(p);
            self.diff_weight[x] += self.diff_weight[p];
            self.par[x] = r;
            r
        }
    }
    fn weight(&mut self,x:usize)->i64{
        self.find(x);
        self.diff_weight[x]
    }
    fn diff(&mut self, x:usize, y:usize)->i64{
        let res = self.weight(x) - self.weight(y);
        res
    }
    fn same(&mut self, a:usize, b:usize)->bool{
        self.find(a) == self.find(b)    
    }
    fn unite(&mut self, xx:usize, yy:usize, ww:i64) -> bool{
        let mut w = ww.clone();
        let mut x = xx.clone();
        let mut y = yy.clone();

        w += self.weight(x);
        w -= self.weight(y);
        x = self.find(x);
        y = self.find(y);
        if (x == y) {return false;}
        if self.rank[x] < self.rank[y]{
            mem::swap(&mut x, &mut y);
            w = -w;
        }

        if self.rank[x] == self.rank[y]{
            self.rank[y] += 1;
        }
        self.par[y] = x;
        self.size[x] += self.size[y];
        self.diff_weight[y] = w;
        return true;
    }
    fn check_size(&mut self, a:usize) -> usize{
        let x = self.find(a);
        let s = self.size[x];
        s    
    }
}





struct UnionFind{
    par:Vec<usize>,
    rank:Vec<usize>,
    size:Vec<usize>,    
}
impl UnionFind{
    fn init(n:usize) -> UnionFind{
        let mut par = vec![0;n];
        for i in 0..n{
            par[i] = i;    
        }
        UnionFind{
            par:par,
            rank:vec![0;n], 
            size:vec![1;n], 
        }
    }
    fn find(&mut self, x:usize) ->usize{
        if(self.par[x] == x){
            x    
        }
        else{
            let p = self.par[x];
            let res = self.find(p);
            self.par[x] = res;
            res
        }
    }
    fn same(&mut self, a:usize, b:usize)->bool{
        self.find(a) == self.find(b)    
    }
    fn unite(&mut self, a:usize, b:usize){
        let x = self.find(a);
        let y = self.find(b);
        if x != y{
            if (self.rank[x] < self.rank[y]){
                self.par[x] = y;
                self.size[y] += self.size[x];
            }
            else{
                self.par[y] = x;
                self.size[x] += self.size[y];
                if(self.rank[x] == self.rank[y]){ self.rank[x]+=1;}
            }
        }
    }
    fn check_size(&mut self, a:usize) -> usize{
        let x = self.find(a);
        let s = self.size[x];
        s    
    }
}
fn gcd(a:usize, b:usize)->usize{
    if b==0{return a;}
    gcd(b, a%b)
}
fn lcm(a: usize, b: usize) -> usize {
    a / gcd(a, b) * b
}
fn extgcd(a:usize, b:usize, x:&mut usize, y:&mut usize)->usize{
    let mut d = a;
    if b != 0{
        d = extgcd(b, a%b, y, x);
        *y -= (a/b) * (*x);    
    }    
    else{
        *x = 1;
        *y = 0;
    }
    d
}

use std::ops::{Deref, DerefMut, Index, IndexMut};
use std::any::{Any, TypeId};

struct vec2<T>(Vec<T>);
 
impl<T> Deref for vec2<T> {
    type Target = Vec<T>;
    fn deref(&self) -> &Vec<T> {
        &self.0
    }
}
 
impl<T> DerefMut for vec2<T> {
    fn deref_mut(&mut self) -> &mut Vec<T> {
        &mut self.0
    }
}
impl<T> Index<i64> for vec2<T> {
    type Output = T;
    fn index(&self, index: i64) -> &T {
        &self.0[index as usize]
    }
}
 
impl<T> IndexMut<i64> for vec2<T> {
    fn index_mut(&mut self, index: i64) -> &mut T {
        &mut self.0[index as usize]
    }
}

fn segment_sieve(a:usize, b:usize) -> Vec<bool>{
    let mut is_prime= vec![false; b+1];
    let mut is_prime_small= vec![false; b+1];
    for i in 0..b{
        if i*i>=b{break;}    
        is_prime_small[i] = true;
    }
    for i in 0..b{
        if i>=b-a{break;}
        is_prime[i] = true;    
    }
    for i in 2..b{
        if i*i>=b{break;}
        if is_prime_small[i] == true{


            let mut j = 2*i;
            while(j*j<b){
                is_prime_small[j] = false;
                j+=i;
            }
            
            j = cmp::max(2, ((a+i-1)/i)*i);
            while(j<b){
                is_prime[j-a] = false;
                j+=i;    
            }    
        }    
    }
    is_prime


}
fn sieve(n:usize) -> (Vec<bool>, Vec<usize>){
    let mut p:usize = 0;
    let mut is_prime = vec![false; n+1];
    let mut prime = Vec::new();
    for i in 0..n+1{
        is_prime[i] = true;
    }
    is_prime[0] = false;
    is_prime[1] = false;
    for i in 2..n+1{
        if is_prime[i]{
            prime.push(i as usize);
            let mut j = 2*i;
            while(j<=n){
                is_prime[j] = false;
                j+=i;
            }
        }
    }
    (is_prime, prime)
    
}
fn divisor(n:usize) -> Vec<usize>{
    let mut res:Vec<usize> = Vec::new(); 
    for i in 1..n+1{
        if i*i>n{break;}
        if n%i == 0{
            res.push(i);
            if i != n/i{
                res.push(n/i);    
            }    
        }    
    }
    res
}

fn prime_factor(nn:usize) -> HashMap<usize, usize>{
    let mut res:HashMap<usize, usize> = HashMap::new();
    let mut n = nn.clone();
    for i in 2..n+1{
        if i*i>n{break;}
        while(n%i == 0){
            *res.entry(i).or_insert(0) += 1;
            n/=i;    
        }    
    }
    if (n != 1){res.insert(n,1);}
    res
}

use std::collections::BinaryHeap;

#[derive(PartialEq)]
struct mf(i64);

impl Eq for mf {}

impl PartialOrd for mf {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        other.0.partial_cmp(&self.0)
    }
}

impl Ord for mf {
    fn cmp(&self, other: &mf) -> Ordering {
        self.partial_cmp(other).unwrap()
    }
}




#[derive(Copy, Clone, Eq, PartialEq)]
struct edge1{from:usize, to:usize, cost:i64}
impl Ord for edge1 {
    fn cmp(&self, other: &edge1) -> Ordering {
        other.cost.cmp(&self.cost)
    }
}

impl PartialOrd for edge1 {
    fn partial_cmp(&self, other: &edge1) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}
fn kruskal(es:&mut Vec<edge1>, n:usize) -> i64{
    es.sort();
    es.reverse();
    let mut uf =  UnionFind::init(n);
    let mut res = 0;
    for i in 0..es.len(){
        let e = es[i];
        if uf.same(e.from, e.to) == false{
            uf.unite(e.from, e.to);
            res += e.cost;
        }

    }
    res
}




fn bellman_ford(s:usize, n:usize, inf:i64, es:&Vec<edge1>) -> Vec<i64>{
    let mut d = vec![inf;n];
    d[s] = 0;
    for j in 0..n-1{
        let mut update = false;
        for i in 0..es.len(){
            let e = es[i];
            if (d[e.from] != inf && d[e.to] > d[e.from] + e.cost){
                d[e.to] = d[e.from] + e.cost;
            }
                
        }
    }

    d
}
fn find_negative_loop(n:usize, es:&Vec<edge1>, inf:i64) -> bool{
    let mut d = vec![0;n];
    for i in 0..n{
        for j in 0..es.len(){
            let e = es[j];
            if d[e.to] > d[e.from] + e.cost{
                d[e.to] = d[e.from] + e.cost;
                if (i == n-1) {return false;}
            }
        }
    }
    return true;
}
#[derive(Copy, Clone, Eq, PartialEq)]
struct State{
    cost: i64,
    position: usize,
}
impl Ord for State {
    fn cmp(&self, other: &State) -> Ordering {
        // Notice that the we flip the ordering on costs.
        // In case of a tie we compare positions - this step is necessary
        // to make implementations of `PartialEq` and `Ord` consistent.
        other.cost.cmp(&self.cost)
    }
}

// `PartialOrd` needs to be implemented as well.
impl PartialOrd for State {
    fn partial_cmp(&self, other: &State) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

struct edge2{
    to:usize,
    cost:i64,
}
fn dijkstra(adj_list: &Vec<Vec<edge2>>, start:usize, inf:i64) -> Vec<i64>{
    let mut d= vec![inf;adj_list.len()];
    let mut heap = BinaryHeap::new();
    d[start] = 0;
    heap.push(State{cost: 0, position: start });
    while (heap.len() != 0){
        let p = heap.pop().unwrap();
        let v = p.position;
        if(d[v] < p.cost) {continue;}
        for i in 0..adj_list[v].len(){
            let e = &adj_list[v][i];
            if d[e.to] > d[v] + e.cost{
                d[e.to] = d[v] + e.cost;
                heap.push(State{cost:d[e.to], position:e.to});
            }
        }
            
    }
    d
        
}
// no verify
fn prim(n:usize, cost:&Vec<Vec<i64>>, inf:i64, s:usize) -> i64{
    let mut mincost = vec![inf;n];
    let mut used = vec![false;n];
    mincost[s] = 0;
    let mut res = 0;
    while(true){
        let mut v:i64 = -1;
        for  u in 0..n{
            if (used[u] == false && (v == -1 || mincost[u] <mincost[v as usize])){v = u.clone() as i64;}
        }
        if v == -1{break;}
        used[v as usize] = true;
        res += mincost[v as usize];
        for u in 0.. n{
            mincost[u] = cmp::min(mincost[u], cost[v as usize][u]);
        }
    }
    return res;
}
//
fn find_negative_loop2(n:usize, es:&Vec<edge1>, inf:i64, dist:&mut Vec<i64>) -> Vec<bool>{
    let mut neg = vec![false;n];
    for i in 0..n{
        for j in 0..es.len(){
            
            let e = es[j];
            if dist[e.from] == inf{continue;}

            if dist[e.to] > dist[e.from] + e.cost{
                dist[e.to] = dist[e.from] + e.cost;
                neg[e.to] = true;
            }
            if neg[e.from] == true{ neg[e.to] = true;}
        }
    }
    return neg;
}
fn mod_for_big_int(k:Vec<char>, C:usize)-> usize{
    let mut k_mod_C = 0;
    for i in 0..k.len(){
        k_mod_C = (k_mod_C*10+(k[i] as usize - 48) as usize)%C;
    }
    k_mod_C
}
/*
fn imos() {
    input!{
        n:usize,
        m:usize,
        q:usize,
        lr:[(usize, usize);m],
        pq:[(usize, usize);q],
    }
    let mut v = vec![vec![0;n+2];n+2];
    for i in 0..m{
        v[lr[i].0][lr[i].1] +=1;
    }
    
    for i in 1..n+2{
        for j in 1..n+2{

            v[i][j] +=v[i-1][j];
        }
    }
    for i in 1..n+2{
        for j in 1..n+2{

            v[i][j] +=v[i][j-1];
        }
    }
    for i in 0..q{
        println!("{}", v[pq[i].1][pq[i].1] - v[pq[i].0-1][pq[i].1] - v[pq[i].1][pq[i].0-1] + v[pq[i].0-1][pq[i].0-1] );
    }
}
*/
fn main(){
    input!{
        n:usize,
        w:usize,
        wv:[(usize, usize);n],
    }
    let mut v:Vec<Vec<usize>> = Vec::new();
    v.push(Vec::new());
    v.push(Vec::new());
    v.push(Vec::new());
    v.push(Vec::new());

    for i in 0..n{
        v[wv[i].0 - wv[0].0].push(wv[i].1);
    }
    for i in 0..4{
        v[i].push(0);

        v[i].sort();
        for j in 1..v[i].len(){
            v[i][j] += v[i][j-1];
        }
        v[i].reverse();
    }
    let mut res = 0;
    let mut base = wv[0].0;
    for i in 0..v[0].len(){
        for j in 0..v[1].len(){
            for k in 0..v[2].len(){
                for l in 0..v[3].len(){
                    if i*base + (base+1)*j + (base+2)*k + (base+3)*l <=w{
                        res = cmp::max(res, v[0][0]-v[0][i] + v[1][0]-v[1][j] + v[2][0]-v[2][k] + v[3][0]-v[3][l]);
                    }
                }
            }
        }
    }
    println!("{}", res);
    
    
}