// {{{ 
#include <bits/stdc++.h>
using namespace std;

#ifdef DEBUG
#include "debug.cpp"
#else
#define dbg(...)
#define dbgarr(...)
#endif

using ull = unsigned long long;
using ll = long long;
using vi = vector<int>;
using vll = vector<long long>;
using vvi = vector<vi>;
using vvll = vector<vll>;
using vs = vector<string>;
using pii = pair<int, int>;

#define pb push_back
#define ms memset
#define el '\n'
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define sz(x) ((int)(x).size())

const int INF = 0x3f3f3f3f;
const ll INFL = 1LL << 60;
const string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const string abc = "abcdefghijklmnopqrstuvwxyz";

template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }

#define rep(i, b) for (auto i = 0; i < (b); i++)
#define reps(i, b) for (auto i = 1; i <= (b); i++)
//#define rrep(i,x) for(int i=((int)(x)-1);i>=0;i--)
//#define rreps(i,x) for(int i=((int)(x));i>0;i--)

template<class T> inline void printvec(const vector<T>& v, bool split_line=false, bool ones=false) {
    if(v.empty()){
        cout << "This vector is empty." << el;
        return;
    }
    if(ones){
        for (int i = 1; i <= (int)v.size(); i++) {
            if(v[i]==INF || v[i]==INFL) cout << 'x' << " \n"[split_line || i+1==(int)v.size()];
            else cout << v[i] << " \n"[split_line || i+1==(int)v.size()];
        }
    }else{
        for (int i = 0; i < (int)v.size(); i++) {
            if(v[i]==INF || v[i]==INFL) cout << 'x' << " \n"[split_line || i+1==(int)v.size()];
            else cout << v[i] << " \n"[split_line || i+1==(int)v.size()];
        }
    }
}

const int dy[4] = {-1,0,1,0};
const int dx[4] = {0,1,0,-1};
const string stepdir = "URDL";

struct Fast {Fast() {std::cin.tie(0); ios::sync_with_stdio(false);}} fast;
// }}}


struct st_t {
    long long val;
    long long lazy;
    static const long long null_l = 0;

    //initial value, used when er initializing & for returning outside node (but technically it shudnt happen i think)
    st_t(): val(0), lazy(null_l) {}

    //used when initializing given a value
    st_t(long long v): val(v), lazy(null_l) {}

    // used when updating when passing a value v
    st_t(bool lz, long long v): lazy(v) {}

    // push up, used in init, returning update & query
    st_t op(st_t& other) {
        return st_t(max(val,other.val));
    }

    // push up when only one node is in range
    st_t op(bool rhs) {
        return *this;
    }

    // applying lazy, used when reaching the final node in update / when theres lazy in querying
    void lazy_app(int size) {
        if(lazy == null_l)return;
        val = max(val,lazy);
    }

    // used when pushing down lazy to children nodes & combining lazy to target node when updating
    long long lazy_comb(st_t& v) {
        return max(lazy,v.lazy);
    }
};

template <typename num_t> 
struct segtree {
    int n;
    int inline ls(int i){return 2*i+1; }
    int inline rs(int i){return 2*i+2; }
    vector<num_t> tree;

    void init(int s, long long* arr) {
        n = s;
        tree = vector<num_t>(4 * s);
        init(0, 0, n - 1, arr);
    }

    void init(int s) {
        n = s;
        tree = vector<num_t>(4 * s);
    }

    num_t init(int i, int l, int r, long long* arr) {
        if (l == r) return tree[i] = num_t(arr[l]);
        int mid = (l + r) / 2;
        num_t a = init(ls(i), l, mid, arr),
              b = init(rs(i), mid + 1, r, arr);
        return tree[i] = a.op(b);
    }

    void update(int l, int r, long long v) {
        if (l > r) return;
        update(0, 0, n - 1, l, r, num_t(true, v));
    }

    num_t update(int i, int tl, int tr, int ql, int qr, num_t v) {
        eval_lazy(i, tl, tr);
	
        if (tr < ql || qr < tl) return tree[i];
        if (ql <= tl && tr <= qr) {
            tree[i].lazy = tree[i].lazy_comb(v);
            eval_lazy(i, tl, tr);
            return tree[i];
        }

        int mid = (tl + tr) / 2;
        num_t a = update(ls(i), tl, mid, ql, qr, v),
              b = update(rs(i), mid + 1, tr, ql, qr, v);
        return tree[i] = a.op(b);
    }

    num_t query(int l, int r) {
        // if (l > r) return num_t::null_v;
        assert(r >= l);
        return query(0, 0, n-1, l, r);
    }

    num_t query(int i, int tl, int tr, int ql, int qr) {
        eval_lazy(i, tl, tr);

        if (ql <= tl && tr <= qr) return tree[i];

        int mid = (tl + tr) / 2;

        if(mid >= ql && qr >= tl && tr >= ql && qr >= mid+1){
            num_t a = query(ls(i), tl, mid, ql, qr);
            num_t b = query(rs(i), mid + 1, tr, ql, qr);
            return a.op(b);
        }else if(mid >= ql && qr >= tl){
            num_t a = query(ls(i), tl, mid, ql, qr);
            return a.op(false);
        }else if(tr >= ql && qr >= mid+1){
            num_t b = query(rs(i), mid + 1, tr, ql, qr);
            return b.op(true);
        }
        return num_t::null_l; // wont happen kot probably
    }

    void eval_lazy(int i, int l, int r) {
        tree[i].lazy_app(r - l + 1);
        if (l != r) {
            tree[ls(i)].lazy = tree[ls(i)].lazy_comb(tree[i]);
            tree[rs(i)].lazy = tree[rs(i)].lazy_comb(tree[i]);
        }
        tree[i].lazy = num_t::null_l;

    }
};


const int mxN = 200001;
segtree<st_t> st;

int n,m;
int main() {
    cin >> n >> m;
    vector<ll> mq(n),sat(n),q(m),d(m);
    for(int i=0; i<n; i++){
        cin >> mq[i] >> sat[i];
    }
    vector<ll> tmp(mq);
    sort(tmp.begin(),tmp.end());
    tmp.erase(unique(tmp.begin(), tmp.end()), tmp.end());
    st.init(n);
    for(int i = 0; i < n; i++){
        mq[i] = lower_bound(tmp.begin(), tmp.end(), mq[i]) - tmp.begin();
        st.update(mq[i],mq[i],sat[i]);
    }
    dbg(st.query(0,n).val);

    ll ans = 0;
    for(int i = 0; i < m; i++){
        cin >> q[i] >> d[i];
        q[i] = upper_bound(tmp.begin(), tmp.end(), q[i]) - tmp.begin() - 1;
        // if(q[i]<0)q[i] = 0;
        ans += max(0LL,st.query(0,q[i]).val - d[i]);
        dbg(ans,d[i]);
    }
    cout << ans << el;


}

/*
 *
 sort all problem by its quality
 for each problem
 look for the largest satisfication among all contest who overcome min


 
 */