#include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
using namespace std;
const int MAX_N=2e2+2;
const long long INF=(1LL<<62);
int n;
long long x[MAX_N];
long long y[MAX_N];
long long cost[MAX_N];
int pos[MAX_N];
bool allzero=1;
vector<pair<pair<long long,int>,long long>>order;
long long distance(long long A,long long B,long long x0,long long y0)
{
return A*x0+B*y0;
}
long long solvefor()
{
long long curbest=0;
for(int i=0;i<order.size();i++)
{
long long cur=0;
for(int j=i;j<order.size();j++)
{
cur+=order[j].second;
curbest=max(curbest,cur);
}
}
return curbest;
}
vector<pair<pair<long long,int>,long long>>norder;
void normalize()
{
norder.clear();
norder.push_back(order[0]);
for(int i=1;i<order.size();i++)
{
if(order[i].first==norder.back().first)
{
norder.back().second+=order[i].second;
continue;
}
norder.push_back(order[i]);
}
swap(order,norder);
}
void solve()
{
for(int i=1;i<=n;i++)
{
order.push_back({{x[i],i},cost[i]});
}
sort(order.begin(),order.end());
normalize();
long long ans=max(0LL,solvefor());
if(!allzero)
{
bool first=1;
int pi,pj;
vector<pair<double,pair<int,int>>>lines;
for(int i=1;i<=n;i++)
{
for(int j=i+1;j<=n;j++)
{
double A=1.0*y[i]-1.0*y[j];
double B=1.0*x[j]-1.0*x[i];
if(B==0)
{
long long C=-A*x[i]-B*y[i];
order.clear();
for(int idx=1;idx<=n;idx++)
{
order.push_back({{distance(A,B,x[idx],y[idx]),idx},cost[idx]});
}
sort(order.begin(),order.end());
int idi=-1,idj;
for(int idx=0;idx<order.size();idx++)
{
if(order[idx].first.first==-C)
{
if(idi==-1)idi=idx;
else idj=idx;
}
}
ans=max(ans,solvefor());
swap(order[idi],order[idj]);
ans=max(ans,solvefor());
continue;
}
lines.push_back({-(A/B),{i,j}});
}
}
sort(lines.begin(),lines.end());
for(auto line:lines)
{
int i=line.second.first;
int j=line.second.second;
long long A=y[i]-y[j];
long long B=x[j]-x[i];
long long C=-A*x[i]-B*y[i];
if(first)
{
order.clear();
for(int idx=1;idx<=n;idx++)
{
order.push_back({{distance(A,B,x[idx],y[idx]),idx},cost[idx]});
}
sort(order.begin(),order.end());
for(int idx=0;idx<n;idx++)
{
pos[order[idx].first.second]=idx;
}
first=0;
}
else
{
if(0 && pos[pi]<pos[pj] && distance(A,B,x[pi],y[pi])>distance(A,B,x[pj],y[pj]))
{
swap(order[pos[pi]],order[pos[pj]]);swap(pos[pi],pos[pj]);
}
/*if(pos[pi]<pos[i] && distance(A,B,x[pi],y[pi])>distance(A,B,x[i],y[i]))
{
swap(order[pos[pi]],order[pos[i]]);swap(pos[pi],pos[i]);
}
if(pos[pj]<pos[i] && distance(A,B,x[pj],y[pj])>distance(A,B,x[i],y[i]))
{
swap(order[pos[pj]],order[pos[i]]);swap(pos[pj],pos[i]);
}
if(pos[pj]<pos[j] && distance(A,B,x[pj],y[pj])>distance(A,B,x[j],y[j]))
{
swap(order[pos[pj]],order[pos[j]]);swap(pos[pj],pos[j]);
}
if(pos[pi]<pos[j] && distance(A,B,x[pi],y[pi])>distance(A,B,x[j],y[j]))
{
swap(order[pos[pi]],order[pos[j]]);swap(pos[pi],pos[j]);
}
if(pos[i]<pos[j] && distance(A,B,x[i],y[i])>distance(A,B,x[j],y[j]))
{
swap(order[pos[i]],order[pos[j]]);swap(pos[i],pos[j]);
}*/
}
int idi=pos[i],idj=pos[j];
ans=max(ans,solvefor());
swap(order[idi],order[idj]);
swap(pos[i],pos[j]);
ans=max(ans,solvefor());
pi=i;
pj=j;
}
}
cout<<ans<<"\n";
}
int main ()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>x[i]>>y[i]>>cost[i];
if(y[i]!=0)allzero=0;
}
solve();
return 0;
}
