//Never forget why you start

 #include<iostream>

 #include<cstdio>

 #include<cstdlib>

 #include<cstring>

 #include<cmath>

 #include<algorithm>

 using namespace std;

 int n,m;

 struct triangle {

     int x,y,d,l,r;//横坐标，纵坐标，直角边长，左端点横坐标，右端点横坐标

     friend bool operator > (const triangle a,const triangle b) {

         return a.l<=b.l&&b.r<=a.r;

     }//定义一个三角形a左右两端点如果完全包含另外一个三角形b，则a>b

 } a[];

 int Next[],pre[],vis[],head,mmax,mmin,len,lastlen,sum[],top,stack[];

 //Next[]表示双向链表的下一个数

 //pre[]表示双向链表的上一个数

 //vis[]表示是否在双向链表中

 //head表示双向链表的第一个点

 double ans;

 void delet(int x) {

     vis[x]=;

     if(head==x)head=Next[x];

     pre[Next[x]]=pre[x];

     Next[pre[x]]=Next[x];

 }//从双向链表中删除一个数

 bool cmp(triangle a,triangle b) {

     if(a.y==b.y)return a.l<=b.l&&b.r<=a.r;

     else return a.y<b.y;

 }//比较函数，先按y从小到大排序，再使前面的三角形完全包含后面的三角形

 int main() {

     int i,j,k,l;

     scanf("%d",&n);

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

         scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].d);

         a[i].r=a[i].x+a[i].d;

         a[i].l=a[i].x;

         vis[i]=;

         Next[i]=i+;

         pre[i]=i-;

         mmin=min(mmin,a[i].y);

         mmax=max(mmax,a[i].y+a[i].d);

     }//输入，初始化双向链表

     sort(a+,a+n+,cmp);//排序

     head=;

     for(i=head; i<=n&&a[i].y==mmin; i=Next[i]) {

         for(j=a[i].l; j<a[i].r; j++) {

             if(!sum[j])len++;

             sum[j]++;

         }

     }//统计最开始被三角形覆盖的长度

     for(i=mmin+; i<=mmax; i++) {

         lastlen=len;//lastlen表示层被覆盖的长度，len表示这一层备覆盖的长度

         top=;//初始化栈

         for(j=head; j<=n&&a[j].y<i; j=Next[j]) {//遍历上一层已经计算过的三角形

             a[j].r--;//因为向上挪了一层，就相当于宽度减小了1

             if(a[j].r<a[j].l)delet(j);//如果这个三角形完全消失，则从双向链表中删去

             else {

                 if(sum[a[j].r]==)len--;//判断r--后是否对len的大小造成影响

                 sum[a[j].r]--;

                 stack[++top]=j;//将这个三角形压入栈中（这个三角形覆盖了一部分长度）

             }

         }

         ans+=(double)(lastlen+len)/2.0;//计算答案

         for(j=head; j<=n&&a[j].y<=i; j=Next[j]) {

             if(a[j].y==i) {//遍历所有覆盖在当前层的三角形

                 for(k=; k<=top; k++) {//遍历所有在栈中的三角形，

                     if(vis[stack[k]]==)continue;

                     if(a[stack[k]]>a[j]) {//判断当前三角形是非已被栈中某个三角形覆盖

                         delet(j);//如果已经覆盖，就在双向链表中将这个三角形删除

                         break;

                     }

                     if(a[j]>a[stack[k]]) {

                         delet(stack[k]);

                         for(l=a[stack[k]].l; l<a[stack[k]].r; l++) {

                             if(sum[l]==)len--;

                             sum[l]--;

                         }//如果栈中三角形被当前三角形覆盖，就删除栈中三角形

                     }

                 }

                 if(k==top+) {//如果所有栈中三角形都无法将当前三角形覆盖，就加入当前三角形

                     for(l=a[j].l; l<a[j].r; l++) {

                         if(!sum[l])len++;

                         sum[l]++;

                     }

                 }

             }

         }

     }

     printf("%.1lf\n",ans);

     return ;

 }