#include <bits/stdc++.h>

using namespace std;

#define fi first
#define se second
#define ll long long
#define file(name)                  \
    if(fopen(name".inp", "r"))      \
        freopen(name".inp", "r", stdin), freopen(name".out", "w", stdout);

template <int Mod>
struct Modular {
private :
    int val;
    static int inverse(int a, int b) {
        a %= b;
        assert(a);
        if(a == 1) return 1;
        return int(b - (long long) inverse(b, a) * (long long) b / a);
    }
public :
    Modular(long long x = 0) : val(x % Mod) { if(val < 0) val += Mod; }

    friend bool operator == (const Modular &a, const Modular &b) { return a.val == b.val; }
    friend bool operator != (const Modular &a, const Modular &b) { return a.val != b.val; }

    Modular& operator = (const long long &x) { val = x % Mod; if(val < 0) val += Mod; return *this; }
    Modular& operator = (const Modular &x) { val = x.val; return *this; }

    friend istream & operator >> (istream &in, Modular &a) { long long x; in >> x; a = Modular(x); return in; }
    friend ostream & operator << (ostream &out, const Modular &a) { return out << a.val; }

    explicit operator int() const { return val; }
    explicit operator bool() const { return val > 0; }

    Modular inv() const {
        Modular res;
        res.val = inverse(val, Mod);
        return res;
    }

    Modular operator ++() { (*this) += 1; return *this; }
    Modular operator --() { (*this) -= 1; return *this; }
    Modular operator ++(int) { (*this) += 1; return *this - 1; }
    Modular operator --(int) { (*this) -= 1; return *this + 1; }

    Modular operator + () const { return *this; }
    Modular operator - () const {
        Modular res;
        res.val = (val ? Mod - val : 0);
        return res;
    }

    Modular& operator += (const Modular &a) {
        val += a.val;
        if(val >= Mod) val -= Mod;
        return *this;
    }
    Modular& operator -= (const Modular &a) {
        val -= a.val;
        if(val < 0) val += Mod;
        return *this;
    }
    Modular& operator *= (const Modular &a) {
        val = 1LL * val * a.val % Mod;
        return *this;
    }
    Modular& operator /= (const Modular &a) {
        (*this) *= a.inv();
        return *this;
    }
    friend Modular operator + (const Modular &a, const Modular &b) { return Modular(a) += b; }
    friend Modular operator - (const Modular &a, const Modular &b) { return Modular(a) -= b; }
    friend Modular operator * (const Modular &a, const Modular &b) { return Modular(a) *= b; }
    friend Modular operator / (const Modular &a, const Modular &b) { return Modular(a) /= b; }
};

// const int Mod = 998244353;
// const int Mod = 1e9 + 9; // 1000000009
const int Mod = 1e9 + 7; // 1000000007

using Modint = Modular <Mod>;

template <class T> T pow(T a, long long b) {
    T ans = 1, mul = a;
    for (; b > 0; b >>= 1) {
        if(b & 1LL) ans *= mul;
        mul *= mul;
    }
    return ans;
}

const int MAX = 1e5 + 5;

int n, q, depth[MAX], anc[MAX][20], sz[MAX];
Modint dist[MAX], dp[MAX], sum[MAX], dp_par[MAX], sum_par[MAX];
vector <pair <int, int>> adj[MAX];

int time_in[MAX], time_out[MAX];

Modint sqr(Modint x) { return x * x; }

void dfs(int u, int p) {
    static int run = 0;
    time_in[u] = ++run;
    depth[u] = depth[p] + 1;
    anc[u][0] = p;
    for (int i = 1; i < 20; ++i) {
        anc[u][i] = anc[anc[u][i - 1]][i - 1];
    }
    sz[u] = 1;
    for (pair <int, int> tmp : adj[u]) if(tmp.fi != p) {
        int v, w; tie(v, w) = tmp;
        dist[v] = dist[u] + w;
        dfs(v, u);
        sum[u] += sum[v] + Modint(1LL * w * sz[v] % Mod);
        dp[u] += sqr(Modint(w)) * sz[v] + 2 * w * sum[v] + dp[v];
        sz[u] += sz[v];
    }
    time_out[u] = run;
}

int __lca(int u, int v) {
    if(depth[u] < depth[v]) swap(u, v);
    for (int i = 19; i >= 0; --i) {
        if(depth[anc[u][i]] >= depth[v]) {
            u = anc[u][i];
        }
    }
    if(u == v) return u;
    for (int i = 19; i >= 0; --i) {
        if(anc[u][i] != anc[v][i]) {
            u = anc[u][i];
            v = anc[v][i];
        }
    }
    return anc[u][0];
}

bool is_par(int u, int v) {
    return time_in[u] <= time_in[v] && time_in[v] <= time_out[u];
}

Modint D(int u, int v) {
    return dist[u] + dist[v] - 2 * dist[__lca(u, v)];
}

void brute_forces() {
    while(q--) {
        int u, v; cin >> u >> v;
        Modint ans = 0;
        for (int i = 1; i <= n; ++i) {
            int sign = (is_par(v, i) ? 1 : -1);
            ans += sqr(D(u, i)) * sign;
        }
        cout << ans << '\n';
    }
    exit(0);
}

void _dfs(int u, int p) {
    for (pair <int, int> tmp : adj[u]) if(tmp.fi != p) {
        int v, w; tie(v, w) = tmp;
        sum_par[v] = sum_par[u] + sum[u] + 1LL * (n - 2 * sz[v]) * w - sum[v];
        dp_par[v] = dp_par[u] + dp[u] -
        (sqr(Modint(w)) * sz[v] + 2 * w * sum[v] + dp[v]) +
        2 * (sum_par[u] + sum[u] - sum[v] - 1LL * sz[v] * w) * w + (n - sz[v]) * sqr(Modint(w));
        _dfs(v, u);
    }
}

void you_make_it(void) {
    cin >> n >> q;
    for (int i = 1; i < n; ++i) {
        int u, v, w; cin >> u >> v >> w;
        adj[u].emplace_back(v, w);
        adj[v].emplace_back(u, w);
    }

    dfs(1, 0), _dfs(1, 0);
//    if(n <= 3000) brute_forces();
//    for (int i = 1; i <= n; ++i) cout << sz[i] << " "; cout << '\n';
//    for (int i = 1; i <= n; ++i) cout << sum[i] << " "; cout << '\n';
//    for (int i = 1; i <= n; ++i) cout << dp[i] << " "; cout << '\n';
//    for (int i = 1; i <= n; ++i) cout << sum_par[i] << " "; cout << '\n';
//    for (int i = 1; i <= n; ++i) cout << dp_par[i] << " "; cout << '\n';
    while(q--) {
        int u, v; cin >> u >> v;
        int x = __lca(u, v);
        Modint ans = 0, res = dist[u] + dist[v] - 2 * dist[x];
        if(x == v) {
            ans = dp[u] + dp_par[u];
            ans -= 2 * (sqr(res) * (n - sz[v]) + 2 * res * sum_par[v] + dp_par[v]);
        } else {
            ans = sz[v] * sqr(res) + 2 * res * sum[v] + dp[v];
            ans = ans * 2 - dp[u] - dp_par[u];
        }
        cout << ans << '\n';
    }
}

signed main() {

#ifdef LOCAL
    freopen("TASK.inp", "r", stdin);
    freopen("TASK.out", "w", stdout);
#endif
    file("tree");
    auto start_time = chrono::steady_clock::now();

    cin.tie(0), cout.tie(0) -> sync_with_stdio(0);

    you_make_it();

    auto end_time = chrono::steady_clock::now();

    cerr << "\nExecution time : " << chrono::duration_cast <chrono::milliseconds> (end_time - start_time).count() << "[ms]" << endl;

    return (0 ^ 0);
}

// Dream it. Wish it. Do it.