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<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cctype>
#include<cstdlib>
#include<algorithm>
#include<bitset>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<map>
#include<set>
#include<stack>
#include<cmath>
#include<sstream>
#include<fstream>
#include<iomanip>
#include<ctime>
#include<complex>
#include<functional>
#include<climits>
#include<cassert>
#include<iterator>
#include<random>
#include<unordered_set>
#include<unordered_map>
using namespace std;

#define MAX 3002

int n;
int m;

long long int dp[2002][3002];

vector<pair<int, int> > v;

vector<pair<int, int> > need;


int main() {
	cin >> n >> m;
	for (int i = 0; i < n; i++) {
		int val, h;
		scanf("%d%d", &val, &h);
		v.push_back(make_pair(val, h));
	}
	for (int i = 0; i < m; i++) {
		int t, s;
		scanf("%d%d", &t, &s);
		need.push_back(make_pair(t, s));
	}
	for (int i = 0; i <= m; i++) {
		for (int j = 0; j <= n; j++) {
			dp[i][j] = LLONG_MIN;
		}
	}
	dp[0][0] = 0;
	for (int i = 0; i < need.size(); i++) {
		long long int have_money = need[i].first;
		long long int mx = LLONG_MIN;
		long long int pv = LLONG_MIN;
		for (int j = 0; j <= n; j++) {  //used
			if (j)have_money -= v[j - 1].first;
			if (j>1)mx += abs(v[j - 1].second - v[j - 2].second);
			mx = max(mx, pv);
			if (j)mx += v[j - 1].second;
			if (have_money < 0LL)break;
			long long int strength = dp[i][j];
			if (strength >= need[i].second) {
				dp[i + 1][j] = max(dp[i + 1][j], strength);
			}
			pv = strength;
			if (mx >= 0LL && mx >= need[i].second) {
				dp[i + 1][j] = max(dp[i + 1][j], mx);
			}
		}
	}
	long long int cost = need.back().first;
	for (int j = 0; j <= n; j++) {
		if (j)cost -= v[j - 1].first;
		if (cost < 0)break;
		if (dp[need.size()][j] >= 0) {
			printf("%lld\n", cost);
			return 0;
		}
	}
	puts("-1");
	return 0;
}