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>

using namespace std;

using i64 = int64_t;

const i64 INF = 1e18 + 7;
const i64 MOD = 1e9 + 7;


signed main(){
    i64 n, m;
    cin >> m >> n;
    vector<i64> cost(m), power(m);
    for(i64 i = 0; i < m; ++i)
        cin >> cost[i] >> power[i];

    vector<i64> time(n), required(n);
    for(i64 i = 0; i < n; ++i)
        cin >> time[i] >> required[i];

    vector<i64> cost_sum(m + 1, 0), power_sum(m + 1, 0), power_diff_sum(m, 0);
    for(i64 i = 0; i < m; ++i){
        cost_sum[i + 1] = cost_sum[i] + cost[i];
        power_sum[i + 1] = power_sum[i] + power[i];
        if(i != m - 1)
            power_diff_sum[i + 1] = power_diff_sum[i] + abs(power[i + 1] - power[i]);
    }

    vector<vector<i64>> abs_sums(m + 1, vector<i64>(m + 1, 0));
    for(i64 j = 0; j <= m; ++j){
        for(i64 k = 0; k <= m; ++k){
            if(k - j >= 2)
                abs_sums[j][k] = abs(power[k - 1] - power[k - 2]);
        }
    }

    vector<vector<i64>> dp(n + 1, vector<i64>(m + 1, -INF));
    dp[0][0] = 0;
    i64 req = 0;
    for(i64 i = 0; i < n; ++i){
        req = max(req, required[i]);
        // for(i64 j = 0; j <= m; ++j){

            i64 now_power = -INF; // dp[i][j];
            i64 now_power_2 = -INF;
            i64 now_power_3 = -INF;
            for(i64 k = 0; k <= m && time[i] >= cost_sum[k]; ++k){
                now_power_3 = dp[i][k];
                if(k){
                    now_power += power[k - 1];
                    now_power_2 += power[k - 1];
                }
                if(k >= 2){
                    now_power += abs(power[k - 1] - power[k - 2]);
                }
                /*
                if(j != k)
                    now_power += power[k - 1];
                if(k - j >= 2)
                    now_power += abs_sums[j][k];
                */
                i64 max_power = max({now_power, now_power_2, now_power_3});
                if(max_power >= req)
                    dp[i + 1][k] = max(dp[i + 1][k], max_power);


                now_power = max(now_power, now_power_2);
                now_power_2 = now_power_3;
                now_power_3 = -INF;
            }
        // }
    }

    for(i64 i = 0; i <= m; ++i){
        i64 money = time.back() - cost_sum[i];
        if(dp.back()[i] >= req){
            cout << money << endl;
            return 0;
        }
    }
    cout << -1 << endl;
}