#![allow(unused_imports)]
//use itertools::{iproduct, Itertools};
use proconio::input;
use proconio::marker::*;
use std::collections::*;

fn main() {
    input! {
        n:usize,
        w:usize,
        d:usize,
        twvs:[(usize,usize,i64);n],
    }

    let twv = [
        twvs.iter()
            .filter(|(t, _, _)| *t == 0)
            .copied()
            .collect::<Vec<_>>(),
        twvs.iter()
            .filter(|(t, _, _)| *t == 1)
            .copied()
            .collect::<Vec<_>>(),
    ];

    const INF: i64 = std::i64::MAX;
    let mut dp = [
        vec![vec![-INF; w + 1]; twv[0].len() + 1],
        vec![vec![-INF; w + 1]; twv[1].len() + 1],
    ];
    dp[0][0][0] = 0;
    dp[1][0][0] = 0;
    for k in 0..2 {
        for i in 0..twv[k].len() {
            for j in 0..=w {
                if dp[k][i][j] == -INF {
                    continue;
                }

                dp[k][i + 1][j] = dp[k][i + 1][j].max(dp[k][i][j]);
                if j + twv[k][i].1 <= w {
                    dp[k][i + 1][j + twv[k][i].1] =
                        dp[k][i + 1][j + twv[k][i].1].max(dp[k][i][j] + twv[k][i].2);
                }
            }
        }
    }

    let mut seg = SegmentTree::new(w + 1, |a, b| a.max(b), |_, new| new, -INF);
    for i in 0..=w {
        seg.update(i, dp[1][twv[1].len()][i]);
    }

    let mut ans = 0;
    for i in 0..=w {
        if dp[0][twv[0].len()][i] == -INF {
            continue;
        }

        let left = i.saturating_sub(d);
        let right = (w - i).min(i + d);
        if left > right {
            continue;
        }

        let score = dp[0][twv[0].len()][i] + seg.query(left, right + 1);
        ans = ans.max(score);
    }

    println!("{}", ans);
}

use segmenttree::*;
mod segmenttree {
    pub struct SegmentTree<T, F: Fn(T, T) -> T, G: Fn(T, T) -> T> {
        n: usize,
        merge: F,
        replace: G,
        unit: T,
        tree: Vec<T>,
    }

    impl<T, F, G> SegmentTree<T, F, G>
    where
        T: Copy,
        F: Fn(T, T) -> T,
        G: Fn(T, T) -> T,
    {
        pub fn new(len: usize, merge: F, replace: G, unit: T) -> Self {
            let mut n = 1;
            while n < len {
                n *= 2;
            }
            Self {
                n,
                merge,
                replace,
                unit,
                tree: vec![unit; 2 * n],
            }
        }

        //0index
        pub fn update(&mut self, mut i: usize, x: T) {
            i += self.n - 1;
            self.tree[i] = (self.replace)(self.tree[i], x);
            while i > 0 {
                i = (i - 1) / 2;
                self.tree[i] = (self.merge)(self.tree[2 * i + 1], self.tree[2 * i + 2]);
            }
        }

        //[l,r)
        pub fn query(&self, l: usize, r: usize) -> T {
            self._query(l, r, 0, 0, self.n)
        }

        fn _query(&self, l: usize, r: usize, i: usize, a: usize, b: usize) -> T {
            if r <= a || b <= l {
                return self.unit;
            }

            if l <= a && b <= r {
                return self.tree[i];
            }

            let res0 = self._query(l, r, 2 * i + 1, a, (a + b) / 2);
            let res1 = self._query(l, r, 2 * i + 2, (a + b) / 2, b);
            (self.merge)(res0, res1)
        }
    }
}