#include <algorithm>

 #define range(i,low,high) for(register int i=(low);i<(high);++i)

 #define dange(i,high,low) for(register int i=(high);i>(low);--i)

 #define __function__(type) __attribute__((optimize("-O2"))) inline type

 #define __procedure__      __attribute__((optimize("-O2"))) inline void

 using namespace std;

 //quick_io {

 #include <cctype>

 #include <cstdio>

 __function__(long long) getint()

 {

     char c=getchar(); for(;!isdigit(c)&&c!='-';c=getchar());

     short s=; for(;c=='-';c=getchar()) s*=-; long long r=;

     for(;isdigit(c);c=getchar()) r=(r<<)+(r<<)+c-''; return r*s;

 }

 //} quick_io

 struct node

 {

     long long x,p,c;

     __procedure__ input() {x=getint(),p=getint(),c=getint();}

     __function__(bool) operator<(const node&t)const{return x<t.x;}

 }factory[];

 int q[]; long long s[]={},sp[]={},f[];

 __function__(long long) getDP(const int&i,const int&j)

 {

     return f[j]+s[i]-s[j]-sp[j]*(factory[i].x-factory[j].x)+factory[i].c;

 }

 __function__(long long) getUP(const int&j,const int&k)

 {

     return f[j]-f[k]-s[j]+s[k]+sp[j]*factory[j].x-sp[k]*factory[k].x;

 }

 __function__(long long) getDOWN(const int&j,const int&k)

 {

     return sp[j]-sp[k];

 }

 int main()

 {

     int n=getint(); range(i,,n+) factory[i].input();

     range(i,,n+)

     {

         s[i]=s[i-]+(factory[i].x-factory[i-].x)*sp[i-];

         sp[i]=sp[i-]+factory[i].p;

     }

     int head=,tail=; sort(factory+,factory+n+),f[]=;

     range(i,,n+)

     {

         for(;head+<tail&&

             getUP(q[head+],q[head])<factory[i].x*getDOWN(q[head+],q[head]);

             ++head

         );

         f[i]=getDP(i,q[head]);

         for(;head+<tail&&

             getUP(i,q[tail-])*getDOWN(q[tail-],q[tail-])<

             getUP(q[tail-],q[tail-])*getDOWN(i,q[tail-]);

             --tail

         );

         q[tail++]=i;

     }

     return printf("%lld\n",f[n]),;

 }