// Author: Grzegorz Herman
// O(nm + q lg^2 m)

#include <algorithm>
#include <array>
#include <iostream>
#include <map>
#include <queue>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;

const int INF = 1000000000;

struct vft : vector<vector<pair<int,int>>>
{
    void init(size_t m)
    {
        clear();
        resize(m, vector<pair<int,int>>(1, make_pair(-1,0)));
    }

    void update(int t, int i, int v)
    {
        for (; i < (int)size(); i |= i+1)
        {
            int w = (*this)[i].back().second + v;
            if ((*this)[i].back().first == t)
                (*this)[i].back().second = w;
            else
                (*this)[i].emplace_back(t, w);
        }
    }

    int prefsum(int t, int i) const
    {
        int sum = 0;
        for (; i >= 0; i = (i&(i+1))-1)
            sum += (lower_bound((*this)[i].begin(), (*this)[i].end(), make_pair(t+1, 0)) - 1)->second;
        return sum;
    }
};

struct graph
{
    struct node : unordered_map<int,int> { };
    typedef array<int,2> edge;
    typedef pair<edge,int> wedge;

    vector<node> V;
    vector<wedge> E;
    vft T;

    graph(int n) : V(n+1), E() { }

    bool replacement(int s, int t, int p, wedge f, wedge & r)
    {
        if (s == t)
        {
            r = f;
            return true;
        }
        for (auto ww: V[s])
            if (ww.first != p && replacement(ww.first, t, s, (f.second < ww.second) ? f : wedge({ s, ww.first }, ww.second), r))
                return true;
        return false;
    }

    void add(int x, int y, int w)
    {
        E.emplace_back(edge({ x, y }), w);
    }

    void freeze()
    {
        sort(E.begin(), E.end(), [](wedge e, wedge f){ return e.second > f.second; });
        T.init(E.size());
        for (int i=0; i<(int)E.size(); ++i)
        {
            wedge r;
            if (replacement(E[i].first[0], E[i].first[1], -1, wedge(edge(), INF), r))
            {
                T.update(i, r.second, -E[r.second].second);
                V[r.first[0]].erase(r.first[1]);
                V[r.first[1]].erase(r.first[0]);
            }
            T.update(i, i, +E[i].second);
            V[E[i].first[0]].emplace(E[i].first[1], i);
            V[E[i].first[1]].emplace(E[i].first[0], i);
        }
    }

    int solve(int l, int h)
    {
        l = upper_bound(E.begin(), E.end(), wedge(edge(), l), [](wedge e, wedge f){ return e.second > f.second; }) - E.begin();
        h = upper_bound(E.begin(), E.end(), wedge(edge(), h+1), [](wedge e, wedge f){ return e.second > f.second; }) - E.begin();
        return T.prefsum(l-1, E.size()-1) - T.prefsum(l-1, h-1);
    }
};

void testcase()
{
    int n, m;
    cin >> n >> m;
    graph G(n);
    for (int i=0; i<m; ++i)
    {
        int x, y, w;
        cin >> x >> y >> w;
        G.add(x, y, w);
    }
    G.freeze();
    int t = 0;
    int q;
    for (cin >> q; q; --q)
    {
        int l, h;
        cin >> l >> h;
        l -= t; h -= t;
        t = G.solve(l, h);
        cout << t << endl;
    }
}

int main()
{
    int z;
    for (cin >> z; z; --z)
        testcase();
    return 0;
}