#include <deque>
#include <vector>
#include <utility>
#include <iostream>
#include <unordered_map>

std::vector<std::unordered_map<int, int>> ReadGraph(int number_nodes, int number_edges) {
    std::vector<std::unordered_map<int, int>> edges(
            static_cast<size_t>(number_nodes) + number_edges + 1);
    std::vector<std::pair<int, int>> double_weight;
    int start, finish, weight;
    while (number_edges--) {
        std::cin >> start >> finish >> weight;
        --start;
        --finish;
        if (start != finish && (edges[start].find(finish) == edges[start].end() ||
                edges[start].at(finish) > weight)) {
            if (weight < 2) {
                edges[start][finish] = weight;
            } else if (weight == 2) {
                double_weight.emplace_back(start, finish);
            }
        }
    }
    auto new_node = number_nodes;
    for (const auto& edge : double_weight) {
        if (edges[edge.first].find(edge.second) == edges[edge.first].end()) {
            edges[edge.first][++new_node] = 1;
            edges[new_node][edge.second] = 1;
        }
    }
    return edges;
}

void BFS(std::vector<std::unordered_map<int, int>>& edges, int start,
         int finish, int number_nodes, int numer_edges) {
    std::deque<int> deque;
    deque.emplace_back(start);
    std::vector<bool> used(static_cast<size_t>(number_nodes) + numer_edges + 1, false);
    std::vector<int> paths_weights(static_cast<size_t>(number_nodes) + numer_edges + 1);
    used[start] = true;
    while (!deque.empty()) {
        int from = deque.front();
        deque.pop_front();
        for (const auto& edge : edges[from]) {
            if (!used[edge.first]) {
                used[edge.first] = true;
                edge.second == 0 ? deque.push_front(edge.first) : deque.push_back(edge.first);
                paths_weights[edge.first] = paths_weights[from] + edge.second;
            }
        }
    }
    if (!used[finish]) {
        std::cout << -1 << "\n";
    } else {
        std::cout << paths_weights[finish] << "\n";
    }
}

void MakeSolution() {
    int number_nodes, number_edges;
    std::cin >> number_nodes >> number_edges;
    auto edges = ReadGraph(number_nodes, number_edges);
    int numer_requests, start, finish;
    std::cin >> numer_requests;
    while (numer_requests--) {
        std::cin >> start >> finish;
        BFS(edges, --start, --finish, number_nodes, number_edges);
    }
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    MakeSolution();
    return 0;
}