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<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


#define NUM 3000
#define SIZE 1000

enum Type{
	pre_no,
	pre_yes,
};

int num_item,num_event;
int price[NUM],add[NUM];
int TIME[SIZE],need_value[SIZE];
int max_value[SIZE+1][NUM+1][2];

int main(){

	scanf("%d %d",&num_item,&num_event);

	for(int i = 0; i < num_item; i++){

		scanf("%d %d",&price[i],&add[i]);
		if(i == 0)continue;
		price[i] += price[i-1];
	}

	for(int i = 0; i < num_event; i++){
		scanf("%d %d",&TIME[i],&need_value[i]);
	}

	for(int event = 0; event <= num_event; event++){
		for(int item = 0; item <= num_item; item++){
			max_value[event][item][pre_no] = -1;
			max_value[event][item][pre_yes] = -1;
		}
	}

	max_value[0][0][pre_no] = 0;

	int no_value,yes_value;

	for(int event = 0; event < num_event; event++){
		for(int item = 0; item <= num_item; item++){

			no_value = max_value[event][item][pre_no];
			yes_value = max_value[event][item][pre_yes];

			if(no_value != -1){

				if(item < num_item && price[item] <= TIME[event]){
					max_value[event][item+1][pre_yes] = max(max_value[event][item+1][pre_yes],no_value+add[item]);
				}

				if(no_value >= need_value[event]){
					max_value[event+1][item][pre_no] = max(max_value[event+1][item][pre_no],no_value);
				}
			}

			if(yes_value == -1)continue;

			if(item < num_item && price[item] <= TIME[event]){
				max_value[event][item+1][pre_yes] = max(max_value[event][item+1][pre_yes],yes_value+add[item]+abs(add[item]-add[item-1]));
			}
			if(yes_value >= need_value[event]){
				max_value[event+1][item][pre_no] = max(max_value[event+1][item][pre_no],yes_value);
			}
		}
	}

	int ans = -1;

	for(int item = 1; item <= num_item; item++){
		if(max_value[num_event][item][pre_no] >= 0){
			ans = TIME[num_event-1]-price[item-1];
			break;
		}
	}

	printf("%d\n",ans);

	return 0;
}