Problem:
Score : 1000 points

Problem Statement

There is a simple undirected graph with N vertices and M edges.
The vertices are numbered 1 through N, and the edges are numbered 1 through M.
Edge i connects Vertex U_i and V_i.
Also, Vertex i has two predetermined integers A_i and B_i.
You will play the following game on this graph.

First, choose one vertex and stand on it, with W yen (the currency of Japan) in your pocket.
Here, A_s \leq W must hold, where s is the vertex you choose.
Then, perform the following two kinds of operations any number of times in any order:

Choose one vertex v that is directly connected by an edge to the vertex you are standing on, and move to vertex v. Here, you need to have at least A_v yen in your pocket when you perform this move.

Donate B_v yen to the vertex v you are standing on. Here, the amount of money in your pocket must not become less than 0 yen.

You win the game when you donate once to every vertex.
Find the smallest initial amount of money W that enables you to win the game.

Constraints

1 \leq N \leq 10^5

N-1 \leq M \leq 10^5

1 \leq A_i,B_i \leq 10^9

1 \leq U_i < V_i \leq N

The given graph is connected and simple (there is at most one edge between any pair of vertices).

Input

Input is given from Standard Input in the following format:

N M
A_1 B_1
A_2 B_2
:
A_N B_N
U_1 V_1
U_2 V_2
:
U_M V_M

Output

Print the smallest initial amount of money W that enables you to win the game.

Sample Input 1

4 5
3 1
1 2
4 1
6 2
1 2
2 3
2 4
1 4
3 4

Sample Output 1

6

If you have 6 yen initially, you can win the game as follows:

Stand on Vertex 4. This is possible since you have not less than 6 yen.

Donate 2 yen to Vertex 4. Now you have 4 yen.

Move to Vertex 3. This is possible since you have not less than 4 yen.

Donate 1 yen to Vertex 3. Now you have 3 yen.

Move to Vertex 2. This is possible since you have not less than 1 yen.

Move to Vertex 1. This is possible since you have not less than 3 yen.

Donate 1 yen to Vertex 1. Now you have 2 yen.

Move to Vertex 2. This is possible since you have not less than 1 yen.

Donate 2 yen to Vertex 2. Now you have 0 yen.

If you have less than 6 yen initially, you cannot win the game. Thus, the answer is 6.

Sample Input 2

5 8
6 4
15 13
15 19
15 1
20 7
1 3
1 4
1 5
2 3
2 4
2 5
3 5
4 5

Sample Output 2

44

Sample Input 3

9 10
131 2
98 79
242 32
231 38
382 82
224 22
140 88
209 70
164 64
6 8
1 6
1 4
1 3
4 7
4 9
3 7
3 9
5 9
2 5

Sample Output 3

582

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include<bits/stdc++.h>
#define pb push_back
using namespace std;
inline int read(){int w=1,s=0;char ch=getchar();while(!isdigit(ch)){if(ch=='-')w=-1;ch=getchar();}while(isdigit(ch)){s=s*10+ch-'0';ch=getchar();}return w*s;}
const int maxn = 2e5;
struct node{
	int next,to;
}e[maxn];
vector<int> edge[maxn]; 
int h[maxn],n,m,a[maxn],point[maxn],b[maxn],fa[maxn],f[maxn],tot;
long long dp[maxn],Sum[maxn];
inline bool cmp(int p,int q){return a[p]<a[q];}
inline void add(int from,int to){e[++tot].to=to,e[tot].next=h[from];h[from]=tot;}
int find(int k){if(f[k]==k)return k;else return f[k]=find(f[k]);} 
void Dfs(int now)
{
	if(edge[now].size()==0)
	{
		Sum[now]=b[now];
		dp[now]=a[now]+b[now];return ;
	}Sum[now]=b[now];
	for(register int i=0;i<edge[now].size();++i)
	{
		int to=edge[now][i];
		Dfs(to);Sum[now]+=Sum[to];
	}
	dp[now]=1e9+8;
	for(register int i=0;i<edge[now].size();++i)
	{
		dp[now]=min(dp[now],max((long long)a[now],dp[edge[now][i]])+Sum[now]-Sum[edge[now][i]]);
	}
} 
int main()
{
	n=read(),m=read();
	for(register int i=1,w1,w2;i<=n;++i) {a[i]=read(),b[i]=read();a[i]=max(0,a[i]-b[i]);point[i]=i;}
	sort(point+1,point+n+1,cmp);
	for(register int i=1,u,v;i<=m;++i) u=read(),v=read(),add(u,v),add(v,u); memset(fa,-1,sizeof(fa));
	for(register int i=1;i<=n;++i)
	{
		int now=point[i];f[now]=now;
		for(register int j=h[now];j;j=e[j].next)
		{
			int to=e[j].to;int Fa=find(to);if(fa[Fa]==0)fa[Fa]=now,f[Fa]=now;
		}
		fa[now]=0;
	}
	int rt;
	for(register int i=1;i<=n;++i){if(fa[i]) edge[fa[i]].pb(i);else rt=i;}
	Dfs(rt);
	cout<<dp[rt];
	return 0;
}