// Slower C++ solution:
#include<bits/stdc++.h>

#include<cstdio>

#define ll long long

#define fi first

#define se second

using namespace std;

typedef pair<ll, ll> lp;

typedef vector<vector<ll>> vvl;

const int inf = 0x3f3f3f3f;

const ll mod = 1e9 + 7;

ll dp[10005][100];//s题

vector<int> a;//s题

int d;   //s题

void A() {

    int n;

    cin >> n;

    vector<int> a(n, 0);

    for(int i = 0; i < n; i++)

        cin >> a[i];

    vector<int> dp(n + 1, inf);

    dp[0] = 0;

    for(int i = 1; i < n; i++) {

        dp[i] = min(dp[i], dp[i - 1] + abs(a[i] - a[i - 1]));

        if(i >= 2)

            dp[i] = min(dp[i], dp[i - 2] + abs(a[i] - a[i - 2]));

    }

    cout << dp[n - 1] << endl;



}

void B() {

    int n, k;

    cin >> n >> k;

    vector<int> dp(n + 1, inf);

    vector<int> h(n, 0);

    for(int i = 0; i < n; i++)

        cin >> h[i];

    dp[0] = 0;

    for(int i = 1; i < n; i++) {

        for(int len = 1; len <= min(k + 1, i + 1); len++) {

            int j = i - len + 1;

            dp[i] = min(dp[i], dp[j] + abs(h[j] - h[i]));

        }

    }

    cout << dp[n - 1] << endl;

}

void C() {

    int n;

    cin >> n;

    vector<vector<int>> a(n, vector<int>(3, 0));

    for(int i = 0; i < n; i++)

        cin >> a[i][0] >> a[i][1] >> a[i][2];

    vector<vector<int>> dp(n, vector<int>(3, 0));

    dp[0][0] = a[0][0];

    dp[0][1] = a[0][1];

    dp[0][2] = a[0][2];

    for(int i = 1; i < n; i++) {

        for(int j = 0; j < 3; j++) {

            for(int k = 0; k < 3; k++) {

                if(j == k)

                    continue;

                dp[i][j] = max(dp[i][j], dp[i - 1][k] + a[i][j]);

                //cout<<dp[i][j]<<endl;

            }

        }

    }

    cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << endl;

}

void D() {

    ll n, W;

    cin >> n >> W;

    vector<lp> p;

    for(int i = 0; i < n; i++) {

        ll a, b;

        cin >> a >> b;

        p.emplace_back(a, b);

    }

    sort(p.begin(), p.end());

    vector<ll> dp(W + 1, 0);

    for(int i = 0; i < n; i++) {

        for(int j = W; j >= p[i].first; j--) {

            if(j > 0)

                dp[j] = max(dp[j], dp[j - 1]);

            dp[j] = max(dp[j], dp[j - p[i].fi] + p[i].se);

        }

    }

    cout << dp[W] << endl;



}

void E() {

    //价值比较小，将dp[i]转化为获得当前i的价值的最小体积，然后根据W寻找符合要求的解；

    int n, W;

    cin >> n >> W;

    vector<ll> w(n, 0);

    vector<ll> v(n, 0);

    for(int i = 0; i < n; i++)

        cin >> w[i] >> v[i];

    vector<ll> dp(100005, inf);

    dp[0] = 0;

    int res = 0;

    for(int i = 0; i < n; i++) {

        for(int j = 1e5; j >= v[i]; j--) {

            dp[j] = min(dp[j], dp[j - v[i]] + w[i]);

            if(dp[j] <= W) {

                res = max(res, j);

            }

        }

    }

    cout << res << endl;



}

void F() {

    string s, t;

    cin >> s >> t;

    int n = s.size(), m = t.size();

    vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));

    for(int i = 1; i <= n; i++) {

        for(int j = 1; j <= m; j++) {

            char a = s[i - 1], b = t[j - 1];

            if(a == b) {

                dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1);

            }

            dp[i][j] = max(dp[i][j], max(dp[i - 1][j], dp[i][j - 1]));

        }

    }

    int i = n, j = m;

    stack<char> st;

    while(i != 0 && j != 0) {

        char a = s[i - 1], b = t[j - 1];

        if(a == b) {

            st.push(a);

            j--;

            i--;

        } else {

            if(dp[i][j] == dp[i - 1][j])

                i--;

            else

                j--;

        }

    }

    string res;

    while(!st.empty()) {

        res += st.top();

        st.pop();

    }

    cout << res << endl;

}

int Ghelper(vector<int>& dp, vector<vector<int>>& edge, int cur, int& ans) {

    if(dp[cur] != -1)

        return dp[cur];

    int res = 0;

    for(auto nb : edge[cur]) {

        res = max(res, Ghelper(dp, edge, nb, ans) + 1);

    }

    ans = max(ans, res);

    dp[cur] = res;

    return res;

}

void G() {

    int n, m;

    cin >> n >> m;

    vector<vector<int>> edge(n + 1, vector<int>());

    for(int i = 0; i < m; i++) {

        int x, y;

        cin >> x >> y;

        edge[x].push_back(y);

    }

    vector<int> dp(n + 1, -1);

//    vector<bool> vis(n+1,0);

    int res = 0;

    for(int i = 1; i <= n; i++) {

//        if(vis[i]) continue;

//        vis[i]=true;

        Ghelper(dp, edge, i, res);

    }

    cout << res << endl;

}

void H() {

    int H, W;

    cin >> H >> W;

    vector<vector<char>> grid(H + 1, vector<char>(W + 1, '.'));

    vector<vector<ll>> dp(H + 1, vector<ll>(W + 1, 0));

    for(int i = 1; i <= H; i++) {

        for(int j = 1; j <= W; j++) {

            cin >> grid[i][j];

        }

    }

    dp[1][1] = 1;

    for(int i = 1; i <= H; i++) {

        for(int j = 1; j <= W; j++) {

            if(i == 1 && j == 1)

                continue;

            if(grid[i][j] == '#')

                dp[i][j] = 0;

            else {

                dp[i][j] = (dp[i - 1][j] + dp[i][j - 1]) % mod;

            }

        }

    }

    cout << dp[H][W] << endl;

}

void I() {

    int n;

    cin >> n;

    vector<vector<double>> dp(n + 1, vector<double>(n + 1, 0.0));

    vector<double> p(n, 0.0);

    for(int i = 0; i < n; i++)

        cin >> p[i];

    dp[0][0] = 1.0;

    for(int i = 1; i <= n; i++) {

        for(int j = 0; j <= i; j++) {

            if(j > 0)

                dp[i][j] += dp[i - 1][j - 1] * p[i - 1];

            dp[i][j] += dp[i - 1][j] * (1 - p[i - 1]);

        }

    }

    double res = 0.0;

    for(int i = (n + 1) / 2; i <= n; i++)

        res += dp[n][i];

    printf("%.10f\n", res);

}

double JHelper(vector<vector<vector<double>>>& dp, int a, int b, int c, int n) {

    //cout<<a<<" "<<b<<" "<<c<<endl;

    if(a == 0 && b == 0 && c == 0)

        return 0;

    if(dp[a][b][c] > 0)

        return dp[a][b][c];

    double sum = a + b + c;

    double ans = 1.0 * n / sum;

    if(a)

        ans += JHelper(dp, a - 1, b, c, n) * (1.0 * a / sum);

    if(b)

        ans += JHelper(dp, a + 1, b - 1, c, n) * (1.0 * b / sum);

    if(c)

        ans += JHelper(dp, a, b + 1, c - 1, n) * (1.0 * c / sum);

    dp[a][b][c] = ans;

    return ans;

}

void J() {

    int n;

    cin >> n;

    vector<int> a(n, 0);

    for(int i = 0; i < n; i++)

        cin >> a[i];

    int cnt[4] = {0, 0, 0, 0};

    for(int i : a) {

        cnt[i]++;

    }

    //cout<<"OK"<<endl;

    vector<vector<vector<double>>> dp(n + 1, vector<vector<double>>(n + 1, vector<double>(n + 1, -1.0)));

    printf("%.13f\n", JHelper(dp, cnt[1], cnt[2], cnt[3], n));

}

//int KHelper(vector<int>& a,vector<int>& dp,int cur,int n)

//{

//    cout<<cur<<" "<<endl;

//    if(dp[cur]!=-1) return dp[cur];

//    dp[cur]=0;

//    for(int i=0;i<n&&cur>=a[i];i++){

//        dp[cur]|=1-KHelper(a,dp,cur-a[i],n);

//        if(dp[cur]==1) break;

//    }

//    return dp[cur];

//}

void K() {

    int n, k;

    cin >> n >> k;

    vector<int> a(n + 1, 0);

    vector<int> dp(k + 3, -1);

    for(int i = 0; i < n; i++) {

        cin >> a[i];

    }

//    if(KHelper(a,dp,k,n)==1) cout<<"First"<<endl;

//    else cout<<"Second"<<endl;

    dp[0] = 0;

    for(int i = 1; i <= k; i++) {

        dp[i] = 0;

        for(int j = 0; j < n && a[j] <= i; j++) {

            dp[i] |= 1 - dp[i - a[j]];

            if(dp[i] == 1)

                break;

        }

    }

    if(dp[k] == 1)

        cout << "First" << endl;

    else

        cout << "Second" << endl;

}

void L() {

    int n;

    cin >> n;

    vector<ll> a(n + 1, 0);

    for(int i = 1; i <= n; i++)

        cin >> a[i];

    vector<vector<ll>> dp(n + 2, vector<ll>(n + 2, 0));

    for(int len = 1; len <= n; len++) {

        for(int i = 1; i + len <= n + 1; i++) {

            int j = i + len - 1;

            if((n - len) % 2 == 0) {

                dp[i][j] = max(dp[i + 1][j] + a[i], dp[i][j - 1] + a[j]);

            } else {

                dp[i][j] = min(dp[i + 1][j] - a[i], dp[i][j - 1] - a[j]);

            }

        }

    }

    cout << dp[1][n] << endl;

}

void M() {

    int n, K;

    cin >> n >> K;

    vector<int> a(n + 1, 0);

    for(int i = 1; i <= n; i++)

        cin >> a[i];

    vector<vector<int>> dp(n + 1, vector<int>(K + 1, 0));

    for(int i = 0; i <= n; i++)

        dp[i][0] = 1;

//    for(int i=0;i<=K;i++) dp[0][i]=1;

    for(int i = 1; i <= n; i++) {

        dp[i][0] = 1;

        for(int j = 0; j < K; j++) {

            dp[i][j + 1] = (dp[i][j + 1] + dp[i][j] + dp[i - 1][j + 1]) % mod;

            if(j >= a[i]) {

                dp[i][j + 1] = (dp[i][j + 1] - dp[i - 1][j - a[i]] + mod) % mod;

            }



        }

    }

    cout << dp[n][K] << endl;

}

void N() {

    int n;

    cin >> n;

    vector<ll> a(n + 1, 0);

    vector<ll> sum(n + 1, 0);

    vector<vector<ll>> dp(n + 1, vector<ll>(n + 1, -1));

    for(int i = 1; i <= n; i++) {

        cin >> a[i];

        sum[i] = sum[i - 1] + a[i];

    }

    for(int i = 1; i <= n - 1; i++) {

        dp[i][i] = 0;

        dp[i][i + 1] = a[i] + a[i + 1];

    }

    dp[n][n] = 0;

    for(int len = 3; len <= n; len++) {

        for(int i = 1; i + len - 1 <= n; i++) {

            int j = i + len - 1;

            for(int k = i; k < j; k++) {

                if(dp[i][j] == -1)

                    dp[i][j] = dp[i][k] + dp[k + 1][j] + sum[j] - sum[i - 1];

                else

                    dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + sum[j] - sum[i - 1]);

            }

        }

    }

    cout << dp[1][n] << endl;

}

void O() {

    int n;

    cin >> n;

    vector<vector<int>> cnt(n + 1, vector<int>(n + 1, 0));

    for(int i = 1; i <= n; i++) {

        for(int j = 1; j <= n; j++) {

            cin >> cnt[i][j];

        }

    }

    vector<int> dp((1 << n), 0);

    dp[0] = 1;

    for(int mask = 1; mask < (1 << n); mask++) {

        bitset<32> bt(mask);

        int i = bt.count();

        //cout<<i<<endl;

        for(int j = 0; j < n; j++) {

            if(cnt[i][j + 1] == 1 && ((mask & (1 << j)) != 0)) {

                dp[mask] = (dp[mask] + dp[mask - (1 << j)]) % mod;

            }

        }

    }

    cout << dp[(1 << n) - 1] << endl;

}

ll PHelper(vector<vector<ll>>& dp, vector<vector<int>>& child, int cur, int flag) {

    if(dp[cur][flag] != -1)

        return dp[cur][flag];

    ll ans = 1;

    for(auto c : child[cur]) {

        if(flag == 1)

            ans = (ans * PHelper(dp, child, c, 0)) % mod;

        else

            ans = (ans * (PHelper(dp, child, c, 0) + PHelper(dp, child, c, 1))) % mod;

    }

    dp[cur][flag] = ans;

    return ans;

}

void P() {

    int n;

    cin >> n;

    vector<vector<int>> child(n + 1, vector<int>());

    vector<vector<ll>> dp(n + 1, vector<ll>(2, -1));

    vector<vector<int>> edge(n + 1, vector<int>());

    for(int i = 0; i < n - 1; i++) {

        int x, y;

        cin >> x >> y;

        edge[x].push_back(y);

        edge[y].push_back(x);

    }

    vector<bool> vis(n + 1, 0);

    vis[1] = true;

    queue<int> q;

    q.push(1);

    while(!q.empty()) {

        auto u = q.front();

        q.pop();

        for(auto e : edge[u]) {

            if(vis[e])

                continue;

            vis[e] = true;

            child[u].push_back(e);

            q.push(e);

        }

    }

    ll res = (PHelper(dp, child, 1, 0) + PHelper(dp, child, 1, 1)) % mod;

    cout << res << endl;

}

void Q() {

    set<lp> cnt;

    int n;

    cin >> n;

    vector<ll> h(n + 1, 0);

    vector<ll> a(n + 1, 0);

    for(int i = 0; i < n; i++)

        cin >> h[i];

    for(int i = 0; i < n; i++)

        cin >> a[i];

    ll res = 0;

    cnt.insert({0, 0});

    for(int i = 0; i < n; i++) {

        //

        ll cur = 0;

        auto it = prev(cnt.lower_bound({h[i], 0}));

        cur = it->second + a[i];

        while(true) {

            auto next = cnt.lower_bound({h[i], 0});

            if(next != cnt.end() && next->second <= cur) {

                cnt.erase(next);

            } else

                break;

        }

        res = max(res, cur);

        cnt.insert({h[i], cur});

    }

    cout << res << endl;

}

void R() {

    ll N, K;

    cin >> N >> K;

    vector<vector<ll>> a(N + 1, vector<ll>(N + 1, 0));

    for(int i = 1; i <= N; i++) {

        for(int j = 1; j <= N; j++) {

            cin >> a[i][j];

        }

    }

    auto amul = [](vvl aa, vvl bb, int n) {

        vector<vector<ll>> t(n + 1, vector<ll>(n + 1, 0));

        for(int i = 1; i <= n; i++) {

            for(int k = 1; k <= n; k++) {

                for(int j = 1; j <= n; j++) {

                    t[i][j] = (t[i][j] + aa[i][k] * bb[k][j]) % mod;

                }

            }

        }

        return t;

    };

    auto power = [&amul](ll k, vvl cur, int n) {

        vvl res(n + 1, vector<ll> (n + 1, 0));

        for(int i = 1; i <= n; i++)

            res[i][i] = 1;

        while(k > 0) {

            if(k & 1)

                res = amul(res, cur, n);

            k = k >> 1;

            cur = amul(cur, cur, n);

        }

        return res;

    };

    ll ans = 0;

    vvl f = power(K, a, N);

    for(int i = 1; i <= N; i++) {

        for(int j = 1; j <= N; j++) {

            ans += f[i][j];

            ans %= mod;

        }

    }

    cout << ans << endl;

}

ll SHelper(int pos, int state, bool limit) {

    //cout<<pos<<" "<<pre<<" "<<state<<" "<<limit<<endl;

    if(pos == -1)

        return state == 0 ? 1ll * 1 : 1ll * 0;

    if(!limit && dp[pos][state] != -1)

        return dp[pos][state];



    int up = limit ? a[pos] : 9;

    //cout<<"ok"<<endl;

    ll ans = 0;

    for(int i = 0; i <= up; i++) {

        ans = (ans + SHelper(pos - 1, (state + i) % d, limit && (i == a[pos]))) % mod;

    }



    if(!limit)

        dp[pos][state] = ans;

    return ans;

};

void S() {

    string k;

    cin >> k >> d;

    int n = k.size() + 1;

    auto solve = [](string s)->ll{

        a.clear();

        memset(dp, -1, sizeof(dp));

        for(int i = s.size() - 1; i >= 0; i--)

            a.push_back(s[i] - '0');

        return SHelper(s.size() - 1, 0, true);

    };

    cout << (mod + solve(k) - solve("0")) % mod << endl;

}

void T() {

    int n;

    cin >> n;

    string s;

    cin >> s;

    vector<vector<ll>> dpt(n + 2, vector<ll> (n + 2, 0));

    dpt[1][1] = 1;

    for(int l = 2; l <= n; l++) {

        if(s[l - 2] == '<') {

            for(int x = 1; x <= l; x++) {

                dpt[l][x] = (dpt[l - 1][x - 1] + dpt[l][x - 1]) % mod;

                //if(dp[l][x]<0) dp[l][x]=(dp[l][x]+mod)%mod;

            }

        } else {

            for(int x = l; x >= 1; x--) {

                dpt[l][x] = (dpt[l][x + 1] + dpt[l - 1][x]) % mod;

                //if(dp[l][x]<0) dp[l][x]=(dp[l][x]+mod)%mod;

            }

        }



    }

    ll ans = 0;

    for(int i = 1; i <= n; i++) {

        ans = (ans + dpt[n][i]) % mod;

    }

    cout << ans % mod << endl;

}

void U() {

    int n;

    cin >> n;

    vector<vector<ll>> a(n + 1, vector<ll>(n + 1));

    for(int i = 0; i < n; i++) {

        for(int j = 0; j < n; j++) {

            cin >> a[i][j];

        }

    }

    int maxn = (1 << n);

    vector<ll> cost(maxn, 0);

    vector<ll> dp(maxn, 0);

    for(int mask = 0; mask < maxn; mask++) {

        for(int i = 0; i < n; i++) {

            for(int j = i + 1; j < n; j++) {

                if(((1 << i)&mask) && ((1 << j)&mask)) {

                    cost[mask] += a[i][j];

                }

            }

        }

    }

    for(int mask = 0; mask < maxn; mask++) {

        for(int submask = mask; submask > 0; submask = (submask - 1)&mask) {

            dp[mask] = max(dp[mask], dp[mask - submask] + cost[submask]);

        }

    }

    cout << dp[maxn - 1] << endl;

}

void Vdfs1(vector<ll>& dp, vvl& child, ll cur, ll mod) {

    dp[cur] = 1;

    for(auto s : child[cur]) {

        Vdfs1(dp, child, s, mod);

        (dp[cur] *= (dp[s] + 1)) %= mod;

    }

}

void Vdfs2(vector<ll>& ans, vector<ll> &dp, vvl& child, ll cur, ll fac, ll mod) {

    ans[cur] = (dp[cur] * fac) % mod;

    vector<ll> prefix, suffix;

    for(auto s : child[cur]) {

        prefix.push_back(dp[s] + 1);

    }

    suffix = prefix;

    for(int i = 1; i < prefix.size(); i++) {

        (prefix[i] *= prefix[i - 1]) %= mod;

    }

    for(int i = (int)(suffix.size() - 2); i >= 0; i--) {

        (suffix[i] *= suffix[i + 1]) %= mod;

    }

    int cnt = 0;

    for(auto s : child[cur]) {

        //计算当前的cur对其孩子的贡献度

        ll curcontribution = fac;

        if(cnt > 0) {

            curcontribution *= prefix[cnt - 1];

            curcontribution %= mod;

        }

        if(cnt < suffix.size() - 1) {

            curcontribution *= suffix[cnt + 1];

            curcontribution %= mod;

        }

        //这里curcontribution+1是指有可能父节点不对该子节点做出贡献

        Vdfs2(ans, dp, child, s, (curcontribution + 1) % mod, mod);

        cnt++;

    }

}

void V() {

    int n, m;

    cin >> n >> m;

    vector<ll> ans(n + 1, 0);

    vector<ll> dp(n + 1, 0);

    vvl edge(n + 1, vector<ll>());

    vvl child(n + 1, vector<ll>());

    for(int i = 0; i < n - 1; i++) {

        int x, y;

        cin >> x >> y;

        edge[x].push_back(y);

        edge[y].push_back(x);

    }

    vector<bool> vis(n + 1, 0);

    vis[1] = 1;

    //建立有根树

    queue<int> q;

    q.push(1);

    while(!q.empty()) {

        auto it = q.front();

        q.pop();

        for(auto nb : edge[it]) {

            if(vis[nb])

                continue;

            vis[nb] = 1;

            child[it].push_back(nb);

            q.push(nb);

        }

    }

    Vdfs1(dp, child, 1, m);

    Vdfs2(ans, dp, child, 1, 1, m);

    for(int i = 1; i <= n; i++)

        cout << ans[i] << endl;

}

void W() {

    //不会线段树，先留着以后补 2020-7-3

}

struct Block {

    ll w, s, v;

    bool operator <(const Block& rhs) const {

        return w + s > rhs.w + rhs.s;

    }

};

void X() {

    int n;

    cin >> n;

    vector<Block> bricks(n);

    for(int i = 0; i < n; i++)

        cin >> bricks[i].w >> bricks[i].s >> bricks[i].v;

    sort(bricks.begin(), bricks.end());

    vector<ll> dp(20055, 0);

    for(auto b : bricks) {

        for(int j = b.w; j < dp.size(); j++) {

            int pre = min(j - b.w, b.s);

            if(dp[pre] < dp[j] + b.v)

                dp[pre] = dp[j] + b.v;

        }

    }

    cout << *max_element(begin(dp), end(dp)) << endl;

}

int main() {

    ios::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);

    X();

}


// Faster C++ solution for the same problem (measured speedup: 1.1404189899842547x):
/*

    -ensure correct output format

    -ensure printing required output

    -reread the problem statement

  */



#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef unsigned long long ull;

typedef pair<ll,ll>pll;

typedef pair<ll,pair<ll,ll>>plll;

#define fastread() (ios_base:: sync_with_stdio(false),cin.tie(NULL));

#define vll(v) v.begin(),v.end()

#define all(x) x.rbegin(),x.rend()

#define min3(a, b, c)   min(a, min(b, c))

#define max3(a, b, c)   max(a, max(b, c))

#define F first

#define S second

#define in  freopen("input.txt", "r", stdin)

#define out  freopen("output.txt", "w", stdout)

#define minheap int,vector<int>,greater<int>

#define pb push_back

#define eb emplace_back

#define ischar(x)  (('a' <= x && x <= 'z') || ('A' <= x && x <= 'Z'))

#define isvowel(ch) ((ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u')||(ch=='A'|| ch=='E' || ch=='I'|| ch=='O'|| ch=='U'))

#define bug cout<<"BUG"<<endl;

const int Max = 2e4 + 10;

const int Mod = 1e9 + 7;

const double PI  =3.141592653589793238463;

bool compare(const pair<ll,ll> &a, const pair<ll,ll> &b)

{

       return (a.first > b.first);

}

ll lcm(ll a,ll b)

{

    if(a==0 || b==0)return 0;



    return a/__gcd(a,b)*b;

}



void input(ll ara[],ll n)

{

    for(ll i=0; i<n; i++)cin>>ara[i];

}







int main()

{



   fastread();



   ll i,j,n,m,p,a,sum=0,k,t,b,c,d,cnt=0,q,l,r;



      bool flag=false;



      string str;





       cin>>n;



     vector<plll>v;



       for(i=0; i<n; i++)

       {

           cin>>a>>b>>c;



          v.pb({a+b,{a,c}});

       }



       sort(vll(v));



       ll mx=0,dp[Max+2]={};







     for(auto x : v)

     {

         ll solid=x.F,w=x.S.F,v=x.S.S;



         for(i=solid-w; i>=0; i--)

         {

              dp[i+w]=max(dp[i+w],dp[i]+v);



              mx=max(mx,dp[i+w]);

         }

     }



     cout<<mx<<endl;









}