Problem: You found an old board game in your programming department's room. It looks interesting so I decided to play with it.

This game consists of M events and you must capture event i at time ti. However, at that time your strength must be si or better, and if you can't be si or better, the game is over. Your strength is 0 at the start of the game (time 0), but you can increase your strength by buying items. Your money at the start of the game is 0, but it increases by 1 per unit time.

The board is ordered with N items each numbered from 1 to N, item i is priced at vi, and purchasing it will increase your strength hi. You can buy as many items as you like at any time if you have enough money, but you must choose the remaining items in ascending order of number. Each item disappears once purchased.

You can also buy multiple items in a row at the same time, and at this time you can get the sum of the hi differences of adjacent items as a bonus. For example, if you buy items 1, 2 and 3 at the same time at a certain time, your strength will increase by | h1 --h2 | + | h2 --h3 | in addition to h1 + h2 + h3.

You want to maximize your money after capturing all the events.

Create a program that inputs item information and event information and outputs the maximum amount of money you have after capturing all the events.



Input

The input is given in the following format.


N M
v1 h1
v2 h2
::
vN hN
t1 s1
t2 s2
::
tM sM


The first line gives the number of items N (1 ≤ N ≤ 3000) and the number of events M (1 ≤ M ≤ 1000). The following N lines give the price vi of item i and the amount of increase in strength hi (1 ≤ vi, hi ≤ 100000). The following M line is given the time ti of event i and the condition si (1 ≤ ti, si ≤ 100000). However, when i <j, ti <tj. All inputs are given as integers.

Output

Output the maximum value of money in your possession on one line. However, if it cannot be captured, "-1" is output.

Examples

Input

5 4
3 3
2 1
1 5
4 2
2 6
4 1
8 2
10 4
12 17


Output

2


Input

5 4
3 3
2 1
1 5
4 2
2 6
4 1
8 2
10 4
12 30


Output

-1

Solution (in CPP):

Solution:

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <cstring>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <list>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <unordered_set>
#include <unordered_map>
#include <array>
#include <cassert>
#include <bitset>
using namespace std;
using LL = long long;

int N, M;
vector<int>v, h;
vector<pair<int, int>>eve;//first=time second=cost

int dp[3333];//iアイテム目までの最大の強さ

int main(void)
{
	cin >> N >> M;
	for (int i = 0; i < N; ++i) {
		int vv, hh;
		cin >> vv >> hh;
		v.push_back(vv);
		h.push_back(hh);
	}
	for (int i = 0; i < M; ++i) {
		int t, s;
		cin >> t >> s;
		eve.push_back({ t,s });
	}
	int vmos = 0;
	int ok = 0;
	for (int i = 1; i <= N; ++i) {
		vmos += v[i - 1];
		auto itr = upper_bound(eve.begin(), eve.end(), pair<int, int>(vmos, 0));
		int limit = 0;
		int ltime = 0;
		if (itr != eve.begin()) {
			itr--;
			ltime = itr->first;
			limit = itr->second;
		}
		else {}
		int nowp = h[i - 1];
		for (int j = i - 1; j >= 0; --j) {
			if (j != i - 1) {
				nowp += abs(h[j] - h[j + 1]);
				nowp += h[j];
			}
			if (limit > dp[j]) {
				break;
			}
			dp[i] = max(dp[i], dp[j] + nowp);
		}
		if (dp[i] == 0) {
			ok = ltime;
			break;
		}
	}
	if (ok != 0) {
		cout << -1 << endl;
		return 0;
	}
	int can = N + 1;
	for (int i = N; i >= 0; --i) {
		if (dp[i] >= eve.back().second) {
			can = i;
		}
		else {
			break;
		}
	}
	if (can == N + 1) {
		cout << -1 << endl;
		return 0;
	}
	int ans = eve.back().first;
	for (int i = 0; i < can; ++i) {
		ans -= v[i];
	}
	cout << ans << endl;
	return 0;
}