#include "bits/stdc++.h"
#define rep(i, a, n) for (auto i = a; i <= (n); ++i)
#define revrep(i, a, n) for (auto i = n; i >= (a); --i)
#define all(a) a.begin(), a.end()
#define sz(a) (int)(a).size()
template<class T> inline bool chmax(T &a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, T b) { if (b < a) { a = b; return 1; } return 0; }
using namespace std;

template<class A, class B> string to_string(const pair<A, B> &p);
template<class A, class B, class C> string to_string(const tuple<A, B, C> &p);
template<class A, class B, class C, class D> string to_string(const tuple<A, B, C, D> &p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string) s); }
string to_string(char c) { return "'" + string(1, c) + "'"; }
string to_string(bool x) { return x ? "true" : "false"; }
template<class A> string to_string(const A &v) {
	bool first = 1;
	string res = "{";
	for (const auto &x: v) {
		if (!first) res += ", ";
		first = 0;
		res += to_string(x);
	}
	res += "}";
	return res;
}
template<class A, class B> string to_string(const pair<A, B> &p) {
	return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template<class A, class B, class C> string to_string(const tuple<A, B, C> &p) {
	return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template<class A, class B, class C, class D> string to_string(const tuple<A, B, C, D> &p) {
	return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}

void debug_out() { cerr << endl; }
template<class H, class... T> void debug_out(const H& h, const T&... t) {
	cerr << " " << to_string(h);
	debug_out(t...);
}
#ifndef ONLINE_JUDGE
	#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
	#define debug(...) if (0) puts("No effect.")
#endif

using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;

/**
 * Author: Yuhao Yao
 * Date: 22-10-24
 * Description: Disjoint set union. $merge(x, y)$ merges components which $x$ and $y$ are in respectively and returns $1$ if $x$ and $y$ are in different components.
 * Time: amortized O(\alpha(M, N)) where $M$ is the number of operations. Almost constant in competitive programming.
 */
struct DSU {
	vi fa, siz;

	DSU(int n): fa(n), siz(n, 1) { iota(all(fa), 0); }

	int getcomp(int x) { 
		return fa[x] == x ? x : fa[x] = getcomp(fa[x]);
	}

	bool merge(int x, int y) {
		int fx = getcomp(x), fy = getcomp(y);
		if (fx == fy) return 0;
		if (siz[fx] < siz[fy]) swap(fx, fy);
		fa[fy] = fx;
		siz[fx] += siz[fy];
		return 1;
	}
};


struct node {
	ll a, b;
	node(ll a = 0, ll b = 0): a(a), b(b) {}
	friend node operator +(const node &lhs, const node &rhs) {
		ll a = max(lhs.a, lhs.a - lhs.b + rhs.a);
		ll b = lhs.b + rhs.b - lhs.a - rhs.a + a;
		return node{a, b};
	}
	friend bool operator <(const node &lhs, const node &rhs) {
		bool negl = lhs.a > lhs.b;
		bool negr = rhs.a > rhs.b;
		if (negl != negr) return negl < negr;
		else if (negl == 0) return lhs.a < rhs.a;
		else return lhs.b > rhs.b;
	}
};

ll hdu6326(const vector<node> &vs, const vvi &g) {
	auto as = vs;
	int n = sz(as);
	vi pars(n);
	auto dfs = [&](auto &dfs, int now, int fa) -> void {
		pars[now] = fa;
		for (auto v: g[now]) if (v != fa) {
			dfs(dfs, v, now);
		}
	};
	dfs(dfs, 0, -1);
	
	DSU dsu(n);
	vi rs(n); iota(all(rs), 0);
	set<pair<node, int>> mp;
	rep(i, 1, n - 1) mp.emplace(as[i], i);
	while (sz(mp)) {
		auto [nd, x] = *mp.begin();
		mp.erase(mp.begin());

		int fx = dsu.getcomp(x);
		int rx = rs[fx];
		assert(x == rx);

		int y = pars[rx];
		int fy = dsu.getcomp(y);
		int ry = rs[fy];

		dsu.merge(x, y);

		rs[fx] = ry;
		rs[fy] = ry;
		if (ry != 0) mp.erase(make_pair(as[ry], ry));
		as[ry] = as[ry] + as[rx];
		if (ry != 0) mp.emplace(as[ry], ry);
	}
	return as[0].a;
}

int main() {
	ios::sync_with_stdio(0); cin.tie(0);

	int n, m; cin >> n >> m;
	vector<node> as(n);
	rep(i, 1, n - 1) cin >> as[i].a >> as[i].b;
	vvi ig(n);
	vi ig_msks(n);
	rep(i, 1, m) {
		int x, y; cin >> x >> y;
		x--, y--;
		ig[y].emplace_back(x);
		ig_msks[y] |= 1 << x;
	}

	const ll inf = 1ll << 60;
	if (n <= 26) {
		int tot = 1 << n;
		vector<ll> dp(tot, -inf), sums(tot);
		dp[1] = 0;
		rep(msk, 1, tot - 1) {
			int low = __builtin_ctz(msk);
			sums[msk] = sums[msk ^ (1 << low)] - as[low].a + as[low].b;
			rep(i, 0, n - 1) if (!(msk >> i & 1)) {
				if (ig_msks[i] & msk) chmax(dp[msk | (1 << i)], min(dp[msk], sums[msk] - as[i].a));
			}
		}
		ll ans = -dp[tot - 1];
		printf("%lld\n", ans);
	} else {
		vi chs(n);
		ll ans = inf;
		auto dfs = [&](auto &dfs, int now) -> void {
			if (now == n) {
				static vvi g(n);
				for (auto &vec: g) vec.clear();
				rep(i, 1, n - 1) g[chs[i]].push_back(i);
				chmin(ans, hdu6326(as, g));
			} else {
				for (auto v: ig[now]) {
					chs[now] = v;
					dfs(dfs, now + 1);
				}
			}
		};
		dfs(dfs, 1);
		printf("%lld\n", ans);
	}	
	return 0;
}