#include <iostream>
#include <algorithm>
#include <iomanip>
#include <cmath>
#include <string>
#include <vector>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <bitset>
#include <map>
#include <fstream>
#include <unordered_map>
#include <numeric>
#include <functional>
#include <unordered_set>
#include <set>
#include <queue>
using namespace std;
typedef long long ll;
void solve();
void init();
int main()
{
    init();
    int t = 1;
    cin >> t;
    while (t--)
        solve();
}

void init()
{
#ifdef ONLINE_JUDGE
    cin.tie(nullptr)->ios::sync_with_stdio(false);
    cout.tie(nullptr);
#endif
}
#define int long long
template <typename T>
class SegTreeLazyRangeAdd
{
public:
    vector<T> tree;
    vector<T> *arr;
    vector<T> ini;
    vector<vector<int>> sets;
    vector<pair<int, int>> lr;
    ll ans;
    int n, root, n4, end;

    void maintain(int cl, int cr, int p)
    {
    }

    T range_sum(int l, int r, int cl, int cr, int p)
    {
        if (l <= cl && cr <= r)
            return tree[p];
        int m = cl + (cr - cl) / 2;
        T sum = 0;
        maintain(cl, cr, p);
        if (l <= m)
            sum += range_sum(l, r, cl, m, p * 2);
        if (r > m)
            sum += range_sum(l, r, m + 1, cr, p * 2 + 1);
        return sum;
    }
    void check(int p, int pl, int pr, vector<int> &sum)
    {
        // cerr<<'!'<<p<<' '<<pl<<' '<<pr<<' '<<tree[p]<<endl;
        if (tree[p] > 1)
            return;
        else if (tree[p] == 1)
        {
            for (auto id : sets[p])
            {
                sum[id] -= (ini[p] - tree[p]);
                if (sum[id] == 1)
                {
                    ans += id * id;
                }
            }
        }
        else
        {
            for (auto id : sets[p])
            {
                sum[id] -= 1;
                if (sum[id] == 0)
                {
                    ans -= id * id;
                }
                if (sum[id] == 1)
                {
                    ans += id * id;
                }
            }
        }
        // cerr<<'*'<<ans<<endl;
    }
    void add(int l, int r, T val, int x, int p, vector<int> &sum)
    {
        if (l == x && r == x)
        {
            tree[p]--;
            check(p, l, r, sum);
            return;
        }
        // maintain(cl, cr, p);
        int m = l + r >> 1;
        if (x <= m)
            add(l, m, val, x, p * 2, sum);
        else
            add(m + 1, r, val, x, p * 2 + 1, sum);
        tree[p] = tree[p * 2] + tree[p * 2 + 1];
        check(p, l, r, sum);
    }
    void setans(ll s)
    {
        ans = s;
    }
    void build(int s, int t, int p)
    {
        lr[p] = {s, t};
        if (s == t)
        {
            ini[p] = tree[p] = (*arr)[s];
            return;
        }
        int m = s + (t - s) / 2;
        build(s, m, p * 2);
        build(m + 1, t, p * 2 + 1);
        ini[p] = tree[p] = tree[p * 2] + tree[p * 2 + 1];
    }

public:
    explicit SegTreeLazyRangeAdd<T>(vector<T> v)
    {
        n = v.size();
        n4 = n * 4;
        ans = 0;
        tree = vector<T>(n4, 0);
        lr = vector<pair<int, int>>(n4);
        ini = tree;
        // lazy = vector<T>(n4, 0);
        sets = vector<vector<int>>(n4);
        arr = &v;
        end = n - 1;
        root = 1;
        build(0, end, 1);
        arr = nullptr;
    }
    void init(int p, int pl, int pr, int l, int r, int id)
    {
        if (pl >= l && pr <= r)
        {
            sets[p].push_back(id);
            return;
        }
        int mid = pl + (pr - pl) / 2;
        // cerr<<p<<' '<<pl<<' '<<pr<<' '<<l<<' '<<r<<endl;
        if (l <= mid)
            init(p * 2, pl, mid, l, r, id);
        if (r > mid)
            init(p * 2 + 1, mid + 1, pr, l, r, id);
    }

    void show()
    {
        cout << "S:";
        for (int i = root; i < n4; i++)
            cout << i << ' ' << lr[i].first << ' ' << lr[i].second << endl;
    }
    void Add(int x, T val, vector<int> &sum) { add(0, end, val, x, root, sum); }
    void Init(int l, int r, int id) { init(root, 0, end, l, r, id); }
};
void solve()
{
    int n, m;
    cin >> n >> m;
    int t = max(n, m);
    vector<int> l(t + 1), r(t + 1);
    for (int i = 1; i <= m; i++)
        cin >> l[i] >> r[i];
    vector<int> a(t + 1);
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    vector<int> init(n + 1, 1);
    SegTreeLazyRangeAdd<int> sgt(init);
    // cout<<sgt.range_sum(2,4,0,n-1,1);
    vector<int> sum(t + 1, 0);
    // vector<vector<pair<int, int>>> nodes(m + 1);
    ll ans = 0;
    for (int i = 1; i <= m; i++)
    {
        sum[i] = r[i] - l[i] + 1;
        if (sum[i] == 1)
            ans += i * i;
    }
    sgt.setans(ans);
    // cerr<<1<<endl;
    for (int i = 1; i <= m; i++)
    {
        // cerr<<i<<' '<<l[i]<<' '<<r[i]<<':';
        // cerr<<nodes[i].size()<<endl;
        sgt.Init(l[i], r[i], i);
        // for(auto x:nodes[i])
        // 	cerr<<x.first<<' '<<x.second<<endl;
        // cerr<<endl;
    }
    cout << ans << ' ';
    for (int i = 1; i <= n; i++)
    {
        a[i] = (a[i] + ans) % n;
        // cerr<<'~'<<a[i]<<' '<<ans<<endl;
        sgt.Add(a[i], -1, sum);
        ans = sgt.ans;
        cout << ans << ' ';
    }
    // sgt.show();
    cout << '\n';
}