#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
#include <queue>
#include <vector>
#include <set>
#include <time.h>
using namespace std;


vector<vector<pair<int, double>>>ad, und;
vector<int>used;
vector<vector<pair<int, double>>> par;

vector<int>dist;
vector<int>level;
vector<vector<int>>dp;
int n, logn;

int lca(int a, int b) {
    if (level[a] > level[b])swap(a, b);
    for (int i = logn - 1; i >= 0; --i) {
        if (level[dp[b][i]] >= level[a]) {
            b = dp[b][i];
        }
    }
    if (a == b)return a;
    int ans = 0;
    for (int i = logn - 1; i >= 0; --i) {
        if (dp[b][i] == dp[a][i]) {
            ans = dp[b][i];
        } else {
            b = dp[b][i];
            a = dp[a][i];
        }
    }
    return ans;
}

void dfs(int u, int p) {
    for (auto v : par[u]) {
        if (v.first == p)continue;
        dfs(v.first, u);
        level[v.first] = level[u] + 1;
        dp[v.first][0] = u;
    }
}

void solve() {
    srand(time(NULL));
    int m;
    cin >> n >> m;
    int n1 = n;
    logn = 1;
    while (n1 != 1) {
        logn++;
        n1 /= 2;
    }

    ad.resize(n);
    und.resize(n);
    used.resize(n);
    level.resize(n);
    map<int, int>weights;
    for (int i = 0; i < m; ++i) {
        int u, v; double l; cin >> u >> v >> l;
        ad[u].push_back({ v, l });
        und[u].push_back({ v, l });
        und[v].push_back({ u, l });
    }
    for (int i = 0; i < n; ++i) {
        sort(und[i].begin(), und[i].end());
        for (int j = 1; j < und[i].size(); ++j) {
            if (und[i][j].first == und[i][j - 1].first) {
                und[i][j].second = min(und[i][j].second, und[i][j - 1].second);
                und[i][j - 1] = { n, 0 };
            }
        }
        sort(und[i].begin(), und[i].end());
        while (und[i].back().first == n)und[i].pop_back();
    }

    int st = rand() % n;
    set<pair<double, int>>mins;
    vector<int>dist(n, 1e9);
    dist[st] = 0;
    mins.insert({ 0, st });
    par.resize(n);;
    while (!mins.empty()) {
        auto rel = *mins.begin();
        mins.erase(mins.begin());
        for (auto v : und[rel.second]) {
            if (dist[v.first] > dist[rel.second] + v.second) {
                dist[v.first] = dist[rel.second] + v.second;
                mins.insert({ dist[v.first], v.first });
                par[rel.second].push_back({ v.first, v.second });
            }
        }
    }
    dp.resize(n, vector<int>(logn));
    dfs(st, st);
    dp[st][0] = st;
    for (int k = 1; k < logn; ++k) {
        for (int i = 0; i < n; ++i) {
            dp[i][k] = dp[dp[i][k - 1]][k - 1];
        }
    }

    int q; cin >> q;
    for (int t = 0; t < q; ++t) {
        int a, b; cin >> a >> b;
        vector<int>dis(n, 1e9);
        dis[a] = 0;
        mins.insert({ 0, a });
        vector<int>prev(n);
        prev[a] = -1;
        while (!mins.empty()) {
            auto rel = *mins.begin();
            mins.erase(mins.begin());
            for (auto v : ad[rel.second]) {
                if (dis[v.first] > dis[rel.second] + v.second) {
                    dis[v.first] = dis[rel.second] + v.second;

                    int lca1 = lca(v.first, b);
                    int lower = dist[v.first] + dist[b] - 2 * dist[lca1];

                    mins.insert({ dis[v.first] + lower, v.first });
                    prev[v.first] = rel.second;
                }
            }
        }
        if (dis[b] == 1e9) {
            cout << -1 << '\n';
            continue;
        }
        vector<int>ans;
        while (b != -1) {
            ans.push_back(b);
            b = prev[b];
        }
        cout << ans.size() << '\n';
        reverse(ans.begin(), ans.end());
        for (auto tr : ans) {
            cout << tr << ' ';
        }
        cout << '\n';
    }

}


int main()
{
    cin.tie(NULL);
    cout.tie(NULL);
    ios_base::sync_with_stdio(false);
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    solve();
}