#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef double db;

const int N = 1e4 + 50;
const int M = 6e4 + 50;
const int Mod = 1e9 + 7;

inline int read()
{
    int x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9')
    {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
    {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    return x * f;
}

int n, m;

int p[N];

int find(int x)
{
    if (x != p[x])
        return p[x] = find(p[x]);
    return x;
}

struct node
{
    int u, v, w;
} a[M];

bool cmp(node x, node y)
{
    return x.w > y.w;
}

struct edge
{
    int to, dis, nxt;
} e[M];

int head[N], cnt;

void add_edge(int u, int v, int w)
{
    ++cnt;
    e[cnt].to = v;
    e[cnt].dis = w;
    e[cnt].nxt = head[u];
    head[u] = cnt;
}

void kruskal()
{
    for (int i = 1; i <= n; ++i)
        p[i] = i;
    int cnt = 1;
    for (int i = 1; i <= m + n - 1; ++i)
    {
        int fx = find(a[i].u), fy = find(a[i].v);
        if (fx != fy)
        {
            p[fx] = fy;
            cnt++;
            add_edge(a[i].u, a[i].v, a[i].w);
        }
        if (cnt == n)
            break;
    }
}

int siz[N], son[N], dep[N], fa[N], top[N], id[N], w[N], idk;

void dfs1(int u, int p)
{
    dep[u] = dep[p] + 1;
    siz[u] = 1;
    fa[u] = p;
    int maxn = -1;
    for (int i = head[u]; i; i = e[i].nxt)
    {
        int v = e[i].to;
        if (v == p)
            continue;
        dfs1(v, u);
        if (siz[v] > maxn)
            maxn = siz[v], son[u] = v;
    }
}

void dfs2(int u, int topf)
{
    top[u] = topf;
    id[u] = ++idk;
    if (!son[u])
        return;
    dfs2(son[u], topf);
    for (int i = head[u]; i; i = e[i].nxt)
    {
        int v = e[i].to;
        if (v == fa[u] || v == son[u])
            continue;
        dfs2(v, v);
    }
}

int Min[N << 2];

int ls(int p) { return p << 1; }
int rs(int p) { return p << 1 | 1; }
void push_up(int p)
{
    Min[p] = min(Min[ls(p)], Min[rs(p)]);
}

void build(int p, int l, int r)
{
    if (l == r)
    {
        Min[p] = w[l];
        return;
    }
    int mid = l + r >> 1;
    build(ls(p), l, mid);
    build(rs(p), mid + 1, r);
    push_up(p);
}

int query(int nx, int ny, int l, int r, int p)
{
    int res = 0x3f3f3f3f;
    if (nx <= l && r <= ny)
    {
        return Min[p];
    }
    int mid = l + r >> 1;
    if (nx <= mid)
        res = min(res, query(nx, ny, l, mid, ls(p)));
    if (ny > mid)
        res = min(res, query(nx, ny, mid + 1, r, rs(p)));
    return res;
}

int query_range(int x, int y)
{
    int res = 0x3f3f3f3f;
    while (top[x] != top[y])
    {
        if (dep[top[x]] < dep[top[y]])
            swap(x, y);
        res = min(res, query(id[son[top[x]]], id[x], 1, n, 1));
        x = fa[top[x]];
    }
    if (dep[x] > dep[y])
        swap(x, y);
    res = min(res, query(id[son[x]], id[y], 1, n, 1));
    return res;
}

int main()
{
    n = read(), m = read();
    for (int i = 1; i <= m; ++i)
    {
        a[i].u = read(), a[i].v = read(), a[i].w = read();
    }
    for (int i = 1; i < n; ++i)
        a[m + i].u = i, a[m + i].v = i + 1, a[m + i].w = -1;
    sort(a + 1, a + m + n, cmp);
    kruskal();
    dfs1(1, 0);
    for (int u = 1; u <= n; ++u)
    {
        for (int i = head[u]; i; i = e[i].nxt)
        {
            int v = e[i].to;
            if (dep[u] < dep[v])
                w[v] = e[i].dis;
            else
                w[u] = e[i].dis;
        }
    }
    dfs2(1, 1);
    build(1, 1, n);
    int q = read();
    while (q--)
    {
        int x = read(), y = read();
        printf("%d\n", query_range(x, y));
    }
    return 0;
}