turbinado

//Слава Україні, Героям слава

#include <bits/stdc++.h>

using namespace std;

using ll = int;

const int MAX = 3e5 + 7;

namespace seg {
    ll seg[4 * MAX], lazy[4 * MAX];
    int n, * v;

    ll build(int p = 1, int l = 0, int r = n - 1) {
        lazy[p] = 0;
        if (l == r) return seg[p] = v[l];
        int m = (l + r) / 2;
        return seg[p] = min(build(2 * p, l, m), build(2 * p + 1, m + 1, r));
    }
    void build(int n2, int* v2) {
        n = n2, v = v2;
        build();
    }
    void prop(int p, int l, int r) {
        if (!lazy[p]) {
            return;
        }
        seg[p] = lazy[p];
        if (l != r) lazy[2 * p] = min(lazy[2 * p], lazy[p]), lazy[2 * p + 1] = min(lazy[p], lazy[2 * p + 1]);
        lazy[p] = 0;
    }
    ll query(int a, int b, int p = 1, int l = 0, int r = n - 1) {
        prop(p, l, r);
        if (a <= l and r <= b) return seg[p];
        if (b < l or r < a) return INT_MAX;
        int m = (l + r) / 2;
        return min(query(a, b, 2 * p, l, m), query(a, b, 2 * p + 1, m + 1, r));
    }
    ll update(int a, int b, int x, int p = 1, int l = 0, int r = n - 1) {
        prop(p, l, r);
        if (a <= l and r <= b) {
            lazy[p] = max(lazy[p], (ll)x);
            prop(p, l, r);
            return seg[p];
        }
        if (b < l or r < a) return seg[p];
        int m = (l + r) / 2;
        return seg[p] = min(update(a, b, x, 2 * p, l, m), update(a, b, x, 2 * p + 1, m + 1, r));
    }
};

namespace hld {
    vector<pair<int, int> > g[MAX];
    int pos[MAX], sz[MAX];
    int sobe[MAX], pai[MAX];
    int h[MAX], v[MAX], t;

    void build_hld(int k, int p = -1, int f = 1) {
        v[pos[k] = t++] = sobe[k]; sz[k] = 1;
        for (auto& i : g[k]) if (i.first != p) {
            int u = i.first;
            int w = i.second;
            sobe[u] = w; pai[u] = k;
            h[u] = (i == g[k][0] ? h[k] : u);
            build_hld(u, k, f); sz[k] += sz[u];

            if (sz[u] > sz[g[k][0].first] or g[k][0].first == p)
                swap(i, g[k][0]);
        }
        if (p * f == -1) build_hld(h[k] = k, -1, t = 0);
    }
    void build(int root = 0) {
        t = 0;
        build_hld(root);
        seg::build(t, v);
    }
    ll query_path(int a, int b) {
        if (a == b) return INT_MAX;
        if (pos[a] < pos[b]) swap(a, b);

        if (h[a] == h[b]) return seg::query(pos[b] + 1, pos[a]);
        return min(seg::query(pos[h[a]], pos[a]), query_path(pai[h[a]], b));
    }
    void update_path(int a, int b, int x) {
        if (a == b) return;
        if (pos[a] < pos[b]) swap(a, b);

        if (h[a] == h[b]) return (void)seg::update(pos[b] + 1, pos[a], x);
        seg::update(pos[h[a]], pos[a], x); update_path(pai[h[a]], b, x);
    }
    ll query_subtree(int a) {
        if (sz[a] == 1) return 0;
        return seg::query(pos[a] + 1, pos[a] + sz[a] - 1);
    }
    void update_subtree(int a, int x) {
        if (sz[a] == 1) return;
        seg::update(pos[a] + 1, pos[a] + sz[a] - 1, x);
    }
    int lca(int a, int b) {
        if (pos[a] < pos[b]) swap(a, b);
        return h[a] == h[b] ? b : lca(pai[h[a]], b);
    }
};

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int n, m;
    cin >> n >> m;
    while(m--) {
        int a, b, c;
        cin >> a >> b >> c;
        hld::g[a].push_back({b, c});
        hld::g[b].push_back({a, c});
    }
    hld::build(1);
    int q;
    cin >> q;
    while(q--) {
        int a, b;
        cin >> a >> b;
        cout << hld::query_path(a, b) << "\n";
    }
    return 0;
}