#pragma GCC optimize("Ofast") // ������������ ���������, �� ��� ������
#pragma GCC optimize("no-stack-protector") //�����
#pragma GCC optimize("unroll-loops") // � ���� ���� ��� �� 100 �� ������ ����� � ��������� �� ��� � 100 ��� �� ������ ��������
#pragma GCC target("sse,sse2,sse3,ssse3,popcnt,abm,mmx,tune=native") // ��� ����� ����� �� ��� 03 02 ��������� � ������ ������� �������� ��� ���� ������������
#pragma GCC optimize("fast-math")
#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cmath>
#include <stack>
#include <iomanip>
#include <fstream>
#include <string>
#include <set>
#include <deque>
#include <queue>
#include <map>
#include <bitset>
#include <random>
#include <list>
#include <unordered_map>
#include <unordered_set>
#include <cassert>

using namespace std;

typedef long long ll;
typedef short sh;
typedef unsigned long long ull;
typedef long double ld;
typedef string str;
//typedef __int128 ultraint;
#define sqrt sqrtl
#define F first
#define S second
#define endl '\n'
#define all(vc666) vc666.begin(), vc666.end()
#define allr(vc666) vc666.rbegin(), vc666.rend()
//#define int long long
#define degug(x) cerr (#x) << " " << (x) << endl;

const ll INF = 2e18;
const ll inf = 2e9 + 3;
const ll ONE = 1, ZERO = 0;
const ll mod = 998244353;
const ll m1 = 1e9 + 575179;
const ll m2 = 1e9 + 87;
const ll LG = 19;
const ll k_mo = 347;
const ll k_sqrt = 347;
const ll p = 79;
ld EPS = 1e-9;
ld PI = 3.1415926535897932384;
ld phi = (sqrt(5) + 1.0) / 2.0;
mt19937_64 rnd(4906);

struct Query {
    int l, r, id;
};

const int N = 1e5 + 10;
vector <pair <int, int> > g[N];//Graph
vector <pair <int, int> > euler_path;//Euler_obhod
int idx[N];//Position of vertex
int ans[N];//Answer of query
int bl[(N + k_sqrt - 1) / k_sqrt][k_sqrt];
int res[(N + k_sqrt - 1) / k_sqrt];
int cnt[N];
vector <Query> Q[(3 * N + k_mo - 1) / k_mo];

//sqrt_decomposition for mex_answer
void add(int x) {
    bl[x / k_sqrt][x % k_sqrt]++;
    if (bl[x / k_sqrt][x % k_sqrt] == 1) {
        res[x / k_sqrt]--;
    }
}

void ira(int x) {
    bl[x / k_sqrt][x % k_sqrt]--;
    if (bl[x / k_sqrt][x % k_sqrt] == 0) {
        res[x / k_sqrt]++;
    }
}

int get_mex() {
    for (int i = 0; true; i++)
        if (res[i] > 0)
            for (int j = 0; true; j++)
                if (bl[i][j] == 0) return i * k_sqrt + j;
}

void dfs(int v, int p, int w) {
    euler_path.push_back({ v, w });
    idx[v] = euler_path.size();
    for (auto u : g[v]) {
        if (u.first == p) continue;
        dfs(u.first, v, u.second);
    }
    euler_path.push_back({ v, w });
}

bool cmp(const Query& a, const Query& b) {
    return a.r < b.r;
}

void solve() {
    int n, q, u, v, x, i, j, l, r;
    cin >> n >> q;
    for (i = 0; i < n - 1; i++) {
        cin >> u >> v >> x;
        u--, v--;
        g[u].push_back({ v, min(x, N - 1) });
        g[v].push_back({ u, min(x, N - 1) });
    }
    dfs(0, -1, N - 1);
    for (i = 0; i < q; i++) {
        cin >> l >> r;;
        l = idx[l - 1];
        r = idx[r - 1];
        if (l > r) {
            swap(l, r);
        }
        r--;
        Q[l / k_mo].push_back({ l, r, i });
    }
    for (i = 0; i < (euler_path.size() + k_mo - 1) / k_mo; i++) {
        sort(all(Q[i]), cmp);
        l = i * k_mo;
        r = l - 1;
        for (j = 0; j < N; j++) {
            cnt[j] = 0;
            bl[j / k_sqrt][j % k_sqrt] = 0;
            res[j / k_sqrt] = k_sqrt;
        }
        for (auto u : Q[i]) {
            while (r < u.r) {
                v = euler_path[r + 1].first;
                x = euler_path[r + 1].second;
                cnt[v]++;
                if (cnt[v] == 1) {
                    add(x);
                }
                else {
                    ira(x);
                }
                r++;
            }
            while (l < u.l) {
                v = euler_path[l].first;
                x = euler_path[l].second;
                cnt[v]--;
                if (cnt[v] == 1) {
                    add(x);
                }
                else {
                    ira(x);
                }
                l++;
            }
            while (l > u.l) {
                v = euler_path[l - 1].first;
                x = euler_path[l - 1].second;
                cnt[v]++;
                if (cnt[v] == 1) {
                    add(x);
                }
                else {
                    ira(x);
                }
                l--;
            }
            ans[u.id] = get_mex();
        }
    }
    for (i = 0; i < q; i++) {
        cout << ans[i] << endl;
    }
}

signed main() {
#ifdef _DEBUG
    freopen("input.txt", "r ", stdin);
    freopen("output.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0);
    cin.tie(NULL);
    cout.tie(NULL);
    int t = 1;
    //cin >> t;
    while (t--) solve();
}
//Deisgned by skimono
//Клуб "Кольца(Серьги)"