#include <bits/stdc++.h>
using namespace std;
using T = long long;
struct Edge {
  int from, to;
  T cost, flow, cap;
  Edge(int _from = 0, int _to = 0, T _cost = 0, T _cap = 0)
      : from(_from), to(_to), cost(_cost), flow(0), cap(_cap) {}
};
const int N = 1234;
const T INF = numeric_limits<T>::max();
int n;
vector<Edge> edges;
vector<int> g[N];
T dist[N];
T pi[N];
int par[N];
long long c[N][N];
void addEdge(int from, int to, T cost, T cap) {
  g[from].push_back(edges.size());
  edges.emplace_back(from, to, cost, cap);
  g[to].push_back(edges.size());
  edges.emplace_back(to, from, -cost, 0);
}
bool dijkstra(int s, int t) {
  for (int i = 0; i <= t; ++i) {
    dist[i] = INF;
    par[i] = -1;
  }
  priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> pq;
  dist[s] = 0;
  pq.push({0, s});
  while (!pq.empty()) {
    auto on = pq.top();
    pq.pop();
    int chosen = on.second;
    T d = on.first;
    if (d > dist[chosen]) continue;
    for (int edge_id : g[chosen]) {
      int to = edges[edge_id].to;
      T cost = edges[edge_id].cost;
      T flowing = edges[edge_id].flow;
      T cap = edges[edge_id].cap;
      if (cap <= flowing) continue;
      if (dist[to] > dist[chosen] + pi[chosen] - pi[to] + cost) {
        dist[to] = dist[chosen] + pi[chosen] - pi[to] + cost;
        par[to] = edge_id;
        pq.push({dist[to], to});
      }
    }
  }
  return dist[t] != INF;
}
void bf(int s, int t) {
  fill(pi, pi + t, INF);
  pi[s] = 0;
  for (int i = 0; i < t; ++i) {
    for (int j = 0; j <= t; ++j) {
      for (int edge_id : g[j]) {
        Edge e = edges[edge_id];
        if (e.cap == 0 or pi[j] == INF) continue;
        int to = e.to;
        T cost = e.cost;
        pi[to] = min(pi[to], pi[j] + cost);
      }
    }
  }
}
T mcmf(int s, int t) {
  T cost = 0, max_flow = 0;
  for (int i = 0; i <= t; ++i) pi[i] = 0;
  while (dijkstra(s, t)) {
    for (int i = 0; i <= t; ++i) {
      pi[i] += dist[i];
    }
    T flow = INF;
    for (int cur = t; par[cur] != -1; cur = edges[par[cur]].from) {
      flow = min(flow, edges[par[cur]].cap - edges[par[cur]].flow);
    }
    for (int cur = t; par[cur] != -1; cur = edges[par[cur]].from) {
      cost += edges[par[cur]].cost * flow;
      edges[par[cur]].flow += flow;
      edges[par[cur] ^ 1].flow -= flow;
    }
    max_flow += flow;
  }
  return cost;
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(nullptr);
  cin >> n;
  for (int i = 0; i < n; ++i) {
    long long a, b, k;
    cin >> a >> b >> k;
    for (long long j = 0; j < n; ++j) {
      long long t = 1LL * a - 1LL * min(k, j) * b;
      t = max(t, 0LL);
      c[i][j] = t;
    }
  }
  for (int i = 0; i < n; ++i) {
    addEdge(0, i + 1, 0, 1);
    addEdge(n + i + 1, 2 * n + 1, 0, 1);
    for (int j = 0; j < n; ++j) {
      addEdge(i + 1, n + j + 1, -c[i][j], 1);
    }
  }
  cout << -mcmf(0, 2 * n + 1) << endl;
  return 0;
}
