#include<iostream>
#include<algorithm>
#define DIM 200005
using namespace std;
int n, m, i, j, u, t;
int p[DIM];
pair<int, int> s[DIM];
long long d[DIM][4], sol;
int cmp(pair<int, int> a, pair<int, int> b) {
    if (a.first == b.first) {
        return a.second > b.second;
    }
    return a.first < b.first;
}
long long cost(int x, int y) {
    if (p[x] <= s[y].second) {
        return 0;
    }
    return p[x] - s[y].second;
}
int main() {
    cin>> t;
    for (; t; t--) {
        cin>> n >> m;
        for (i = 1; i <= n; i++) {
            cin>> p[i];
        }
        sort(p + 1, p + n + 1);
        for (i = 1; i <= m; i++) {
            cin>> s[i].first >> s[i].second;
        }
        sort(s + 1, s + m + 1, cmp);
        u = 1;
        for (i = 2; i <= m; i++) {
            if (s[i].second <= s[u].second) {
                s[u] = s[i];
            }
            else {
                s[++u] = s[i];
            }
        }
        m = u;

        u = 1;
        for (i = 1; i <= m; i++){
            while(u <= n && p[u] < s[i].first) {
                u++;
            }

            if (u > 1) {
                if (i != 1 && p[u - 1] < s[i - 1].first) {
                    d[i][0] = d[i - 1][0] + s[i].first - s[i - 1].first;
                    d[i][1] = d[i - 1][1] + 2 * (s[i].first - s[i - 1].first);
                }
                else {
                    if (u == 2 || p[u - 2] < s[i - 1].first) {
                        d[i][0] = s[i].first - p[u - 1] + min(d[i - 1][3], min(d[i - 1][0], d[i - 1][1]));
                        d[i][1] = 2 * (s[i].first - p[u - 1]) + min(d[i - 1][2], min(d[i - 1][0], d[i - 1][1]));
                    }
                    else {
                        d[i][0] = s[i].first - p[u - 1] + min(min(d[i - 1][0], d[i - 1][1]), min(d[i - 1][2], d[i - 1][3]));
                        d[i][1] = 2 * (s[i].first - p[u - 1]) + min(min(d[i - 1][0], d[i - 1][1]), min(d[i - 1][2], d[i - 1][3]));
                    }
                }
            }
            else {
                d[i][0] = d[i][1] = 1000000000000000LL;
            }

            if (u <= n) {
                if (i > 1 && (u == 1 || p[u - 1] < s[i - 1].first) ) {
                    d[i][2] = d[i - 1][2];
                    d[i][3] = d[i - 1][3];
                }
                else {
                    d[i][2] = cost(u, i) + min(min(d[i - 1][0], d[i - 1][1]), min(d[i - 1][2], d[i - 1][3]));
                    d[i][3] = 2 * cost(u, i) + min(min(d[i - 1][0], d[i - 1][1]), min(d[i - 1][2], d[i - 1][3]));
                }
            }
            else {
                d[i][2] = d[i][3] = 1000000000000000LL;
            }
        }
        sol = min(d[m][0], d[m][1]);
        sol = min(sol, d[m][2]);
        sol = min(sol, d[m][3]);
        cout<< sol <<"\n";
    }
}