/*
    created : 2024-08-24 16:53:21
*/
#include <bits/stdc++.h>

using namespace std;

#ifdef LOCAL
#include "Library/debug.h"
#else
#define debug(...) 42
#endif


struct UFDS {
    std::vector<int> p, e, l, r;
    int n;
 
    UFDS(int _n) : n(_n) {
        e.assign(n, 1);
        p.resize(n);
        l.resize(n);
        r.resize(n);
        iota(p.begin(), p.end(), 0);
    }

    void setup(vector<int>left, vector<int>right) {
        l = left;
        r = right;
    }
 
    inline int root(int x) {
        return (x == p[x] ? x : (p[x] = root(p[x])));
    }
 
    inline int size(int x) {
        return e[root(x)];
    }
 
    inline bool joint(int x, int y) {
        x = root(x);
        y = root(y);
        if(x != y) {
            if(e[x] < e[y])
                std::swap(x, y);
            p[y] = x;
            l[x] = min(l[x], l[y]);
            r[x] = max(r[x], r[y]);
            e[x] += e[y];
            return true;
        }
        return false;
    }

    inline bool connected(int x, int y) {
        return root(x) == root(y);
    }
};

int main() {
    ios_base::sync_with_stdio(false); cin.tie(nullptr);
    int n, k; cin >> n >> k;
    vector<int>l(n), r(n), seq(k);
    for(int i = 0; i < n; ++i) {
        cin >> l[i] >> r[i];
    }
    for(auto &s : seq){ 
        cin >> s;
        s--;
    }
    UFDS dsu(n);
    dsu.setup(l, r);
    // l[0] < l[1] < l[2]
    // r[0] < r[1] < r[2]
    auto inter = [](int a, int b, int c, int d) {
        return max(a, c) <= min(b, d);
    };
    int lo = l[0], hi = r[0], last = 0;
    for(int i = 0; i < n; ++i) {
        if(inter(lo, hi, l[i], r[i])) {
            dsu.joint(i, last);
            hi = max(hi, r[i]);
        } else {
            lo = l[i], hi = r[i], last = i;
        }
    }
    set<int>range;
    for(int i = 0; i < n; ++i) {
        range.insert(dsu.root(i));
    }
    map<int,int>comp, inv;
    int cnt = 0;
    for(auto r : range) {
        comp[cnt] = r;
        inv[r] = cnt++;
    }
    last = dsu.r[dsu.root(0)];
    vector<int64_t>pref(cnt);
    for(int i = 1; i < cnt; ++i) {
        int v = comp[i];
        pref[i] += pref[i - 1] + 1LL * (dsu.l[v] - last);
        last = dsu.r[v];
    }
    int64_t ans = pref[inv[dsu.root(seq[0])]] - pref[inv[dsu.root(0)]];
    for(int i = 1; i < k; ++i) {
        int le = seq[i - 1], ri = seq[i];
        if(le > ri) swap(le, ri);
        le = dsu.root(le);
        ri = dsu.root(ri);
        if(le == ri) continue;
        ans += pref[inv[ri]] - pref[inv[le]];
    }
    cout << ans << '\n';
    return 0;
}