#include <bits/stdc++.h>
typedef long long LL;
using namespace std;
const int maxn=1e5+10;
int n,ans,dp[11][11][11][11][11];
int main()
{
	//咋个就一开始没转过来呢
	cin>>n;
	for(int i=1;i<=n;i++){
		int a,b,c,d,e;
		cin>>a>>b>>c>>d>>e;
		for(int j=1;j<=9;j++){
			dp[(a+j)%10][b][c][d][e]++;
			dp[a][(b+j)%10][c][d][e]++;
			dp[a][b][(c+j)%10][d][e]++;
			dp[a][b][c][(d+j)%10][e]++;
			dp[a][b][c][d][(e+j)%10]++;
			dp[(a+j)%10][(b+j)%10][c][d][e]++;
			dp[a][(b+j)%10][(c+j)%10][d][e]++;
			dp[a][b][(c+j)%10][(d+j)%10][e]++;
			dp[a][b][c][(d+j)%10][(e+j)%10]++;
		}
	}
	for(int i=0;i<=9;i++){
		for(int j=0;j<=9;j++){
			for(int k=0;k<=9;k++){
				for(int t=0;t<=9;t++){
					for(int p=0;p<=9;p++){
						if(dp[i][j][k][t][p]==n) ans++;
					}
				}
			}
		}
	}
	cout<<ans<<endl;
	return 0;
}

#include <bits/stdc++.h>
typedef long long LL;
using namespace std;
const int maxn=2e6+10;
//感觉有点kmp算法的思想
//记录跳转的地方，让fi表示以i结尾的合法区间个数，fi=fj+1，那么（j+1,i)是一个合法的区间
//要保证最大。那么(j+1,i)是以i结尾的最短合法区间
int dp[maxn] ,las[maxn];
int main()
{
	int n;cin>>n;
	string s;
	cin>>s;
	s='%'+s; //加个东西
	LL ans=0;
	for(int i=1;i<=n;i++){
		for(int j=i-1;j>0;j=las[j]-1){
			if(s[i]==s[j]){
				las[i]=j;break;
			}
		}
		if(las[i]) dp[i]=dp[las[i]-1]+1,ans+=dp[i];
	} 
	cout<<ans<<endl;
	return 0;
}

#include <bits/stdc++.h>

using namespace std;
#define LL long long
const int maxn=2e6+10;
//这个模拟比较难写，很多细节、结构体、指针很多应用
struct jiegou{
	string name,type; //别名和类型
	LL len,dp,py;
	//长度、对齐、相对父亲的偏移
	vector<jiegou *>son; //儿子（内涵的结构体）
	jiegou(){ py=len=dp=0;name=type="";
	} 
	jiegou(LL len,string tp){
		this->py=0;this->len=len;this->dp=len;
		this->type=tp;
	}
};
map<string,jiegou> mp; //初始化结构体
LL js(LL a,LL b){
	return a/b+int(a%b>0); //向上取整，计算偏移的时候需要 
} 
void build(string x,LL k){ //类型是x，里面有k个元素
	 jiegou tmp;
	 tmp.type=x;
 	 LL py=0;
 	 jiegou *las;
 	 for(LL i=1;i<=k;i++){
 	 	string tpe,bieming;
 	 	cin>>tpe>>bieming;
 	 	jiegou *tmp1=new jiegou(mp[tpe]);
 	 	tmp1->name=bieming;
 	 	tmp.dp=max(tmp.dp,tmp1->dp);  //对齐长度取长度最大的元素
		if(i>1){
			tmp1->py=tmp1->dp*js(las->py+las->len,tmp1->dp); //计算这个元素的起始位置
			//就是这个元素的对齐长度乘以 上一个元素的偏移量加上长度除以这个元素的对齐长度并向上取整 
		} 
 	 	tmp.son.push_back(tmp1);
 	 	las=tmp1;
	  }
	  tmp.len=tmp.dp*js(las->len+las->py,tmp.dp); //整个结构体的长度
	  mp[x]=tmp;
	  cout<<tmp.len<<" "<<tmp.dp<<endl; //输出结构体的长度和对齐 
}
// 2  -> 加入内存
jiegou *tr=new jiegou(); //初识时没有初始化的结构体变量 
void add(string tpe,string name){
	jiegou *tmp=new jiegou(mp[tpe]);
	tmp->name=name;
	LL x,y,st=0;
	vector<jiegou *> vec=tr->son; //一开始是空的！！现在创建一个加入一个 
	if(vec.empty()){
		x=0;y=0;
	}
	else{
		x=(*--vec.end())->py;
		y=(*--vec.end())->len;
	}
	st=js(x+y,tmp->dp)*tmp->dp;  //偏移值 
	tmp->py=st; //这个元素的偏移 
	tr->son.push_back(tmp);
	cout<<st<<endl;
} 
//3 -->直接暴力分割出来每一层索引的名字然后暴力一层一层跳就可以了
LL findd(string x){
	vector<string> vec;
	LL las=0,len=x.length();
	for(LL i=1;i<=len;i++){
		if(x[i-1]=='.') vec.push_back(x.substr(las,i-las-1)),las=i;
		//一层层放进去 
	}
	vec.push_back(x.substr(las,len-las));
	jiegou *now=tr;
	LL st=0,py;
	for(LL i=1;i<=vec.size();i++){
		py=st;
		for(int j=1;j<=now->son.size();j++){
			jiegou *k=now->son[j-1];
			py=st+k->py;
			if(k->name==vec[i-1]){
				st=py;
				now=k; //这个也在往里走，往里面搜索每一个元素 
				break;
			}
		}
		
	}
	return py; 
}
// 4  -->递归找一下，暴力一层层跳，递归存一下目前的总偏移量，如果子节点包含这个区间就往下找
string getb(jiegou *now,LL st,LL tar){
	string ans="";
	for(LL i=1;i<=now->son.size();i++){
		jiegou *k=now->son[i-1];
		if(st+(k->py)<=tar&&tar<st+(k->py)+(k->len)){ //在这个结构体里面 
			ans=k->name;
			if(k->son.size()) ans+="."+getb(k,st+(k->py),tar);
			break;
		}
	}
	if(ans.empty()) return "ERR";  //如果要返回err，实际上只有最后一层是err，因为有可能在一个结构体里面，知只是没有被占据 
	else return ans;
} 
int main()
{
	LL n;
	cin>>n;
	mp["long"]=jiegou(8ll,"long");
	mp["int"]=jiegou(4ll,"int");
	mp["short"]=jiegou(2ll,"short");
	mp["byte"]=jiegou(1ll,"byte");
	for(LL i=1;i<=n;i++){
		int opt;
		cin>>opt;
		if(opt==1){
			string x;LL y;
			cin>>x>>y;
			build(x,y);
		}
		else if(opt==2){
			string x,y;
			cin>>x>>y;
			add(x,y);
		}
		else if(opt==3){
			string x;cin>>x;
			cout<<findd(x)<<endl;
		}
		else if(opt==4){
			LL adr;cin>>adr;
			string ans=getb(tr,0,adr);
			if(ans.find("ERR")!=-1) cout<<"ERR"<<endl;
			else cout<<ans<<endl;
		}
	}
	return 0;
}

#include <bits/stdc++.h>
using namespace std;
typedef __int128 LL;
const int maxn=1e5+100;
const int INF=1e10;
//。虽然知道有单调性 但是要写出二分还是比较难  --- 二层二分 
//https://www.luogu.com.cn/blog/979266/p9755-csp-s-2023-zhong-shu  写的比较好
//首先因为bi+cix 这个是单调的所以可以从这里入手二分(区分什么时候取bi+cix什么时候取1），我们可以对于每一个地块i，求出最晚种树且到 x天时能到达 ai的天数ki 
//对于每个点i可以在1——ki之间任意一个时间种树，每个时间只能种一棵树，球有没有满足的方案
//贪心做法：将ki从小到大排序，然后按照树的结构去判断是否有这样的方案（暴力枚举每个点到父亲的路上是否中了树）并且这个时间是否超过ki 
//开__int128
inline LL read(){
    LL x=0,f=1;
    char c=getchar();
    while(c<'0'||c>'9'){
        if(c=='-')
          f=-1;
        c=getchar();
    }
    while(c>='0'&&c<='9'){
        x=(x<<1)+(x<<3)+(c^48);
        c=getchar();
    }
    return x*f;
}
inline void write(LL x){
	if(x<0){
		putchar('-');
		x=-x;
	}
	if(x>9)
	  write(x/10);
	putchar(x%10+'0');
} 
struct node{
	LL x,y; //表示最晚开始的天数，节点标号
	bool operator < (const node &yyy)const{
	return x<yyy.x;
	} 
}k[maxn];
LL n;
LL a[maxn],b[maxn],c[maxn],h[maxn],p[maxn],fa[maxn];
//h数组就是每个节点的最晚种树节点 
bool vis[maxn];
vector<LL> e[maxn]; //树 
void adde(LL u,LL v){
	e[u].push_back(v);
	e[v].push_back(u); 
} 
void dfs(LL u,LL f){
	for(int i=0;i<e[u].size();i++){
		LL op=e[u][i];
		if(op==f) continue;
		fa[op]=u;
		dfs(op,u);
	}
}
LL js(LL i,LL l,LL r){ //计算第i课树，从l到r天的生长总长度
	LL t=r-l+1;
	if(h[i]<l) return t;
	if(h[i]>r) return t*b[i]+(((l+r)*t)/2)*c[i]; //只有前半部分 
	return (r-h[i])+(h[i]-l+1)*b[i]+(((l+h[i])*(h[i]-l+1))/2)*c[i];
	
}
bool check(LL x){
	for(int i=1;i<=n;i++){
		if(js(i,1,x)<a[i]) return 0; //如果最多x天，那么就算是从第一天开始也不行，说明肯定不是合法的方案 
		LL l=1,r=n; //看从第几个开始种树
		while(l<r){
			LL mid=(l+r+1)>>1;
			if(js(i,mid,x)>=a[i]) l=mid;
			else r=mid-1;
		}
		k[i]={l,i};
		p[i]=k[i].x; //最晚开始的时间   要多余记录这个，因为后面要比较 
	}
	memset(vis,0,sizeof(vis));
	sort(k+1,k+1+n); 
	vis[0]=1;
	LL ttt=0;
	for(int i=1;i<=n;i++){
		stack<LL> d;
		LL t=k[i].y;
		while(!vis[t]){
			d.push(t);
			vis[d.top()]=1;
			t=fa[t]; //往上走  因为肯定这些没有被种 
		}
		while(!d.empty()){
			++ttt;
			if(p[d.top()]<ttt) return 0;  //如果这个时间开始满足在最晚开始时间之前 
			d.pop();
		}
	}
	return 1;
}
int main(){
//	scanf("%lld",&n);
//	for(int i=1;i<=n;i++) scanf("%lld %lld %lld",&a[i],&b[i],&c[i]);
//	for(LL u,v,i=1;i<=n-1;i++){
//		scanf("%lld %lld",&u,&v);adde(u,v);
//	} 
	n=read();
	for(int i=1;i<=n;i++){
		a[i]=read();
		b[i]=read();
		c[i]=read();
	}
	for(int u,v,i=1;i<n;i++){
		u=read(),v=read();
		adde(u,v);
	}
	for(int i=1;i<=n;i++){
		if(c[i]>=0) h[i]=INF;
		else h[i]=(1-b[i])/c[i];
	}
	dfs(1,1);
	LL l=n,r=1e9;  //l起始值为n 
	while(l<r){
		LL mid=(l+r)>>1;
		if(check(mid)) r=mid;
		else l=mid+1; 
	}
	write(l);
	return 0;
}