#include <algorithm>
#include <cstdint>
#include <iostream>
#include <stack>
#include <utility>
#include <vector>

namespace {
using std::cin;
using std::cout;
using std::int64_t;

const int kMaxN = 5.0e4 + 5, kInf = 1.0e9 + 5;
int n, m, q;
int deg[kMaxN];
std::vector<std::pair<int, int>> edges[kMaxN];

struct Point {
  int x, y;
  Point(int x, int y) : x(x), y(y) {}
};

inline bool operator==(const Point &a, const Point &b) {
  return a.x == b.x && a.y == b.y;
}

inline bool operator<(const Point &a, const Point &b) {
  return a.x == b.x ? a.y < b.y : a.x < b.x;
}

std::vector<Point> paths[kMaxN];

std::vector<Point> ConvexHull(std::vector<Point> polygon) {
  std::sort(polygon.begin(), polygon.end());
  polygon.erase(std::unique(polygon.begin(), polygon.end()), polygon.end());
  std::vector<Point> convex_hull;

  auto check = [](const Point &a, const Point &b, const Point &c) {
    return int64_t{a.y - b.y} * (c.x - b.x) > int64_t{b.y - c.y} * (b.x - a.x);
  };

  for (const Point &a : polygon) {
    while (convex_hull.size() >= 2 &&
           check(convex_hull.end()[-2], convex_hull.back(), a)) {
      convex_hull.pop_back();
    }

    convex_hull.emplace_back(a);
  }

  return convex_hull;
}

void Topo() {
  std::stack<int, std::vector<int>> stk;

  for (int i = 1; i <= n; ++i) {
    if (deg[i] == 0) paths[i].emplace_back(0, 0), stk.emplace(i);
  }

  while (!stk.empty()) {
    int u = stk.top();
    stk.pop();
    paths[u] = ConvexHull(std::move(paths[u]));

    for (const auto &edge : edges[u]) {
      int v = edge.first, w = edge.second;

      if (w == 0) {
        for (const Point &path : paths[u]) {
          paths[v].emplace_back(path.x + 1, path.y);
        }
      } else {
        for (const Point &path : paths[u]) {
          paths[v].emplace_back(path.x, path.y + 1);
        }
      }

      if (--deg[v] == 0) stk.emplace(v);
    }
  }
}
}  // namespace

int main() {
  cin.tie(nullptr);
  std::ios::sync_with_stdio(false);
  cin >> n >> m;

  while (m--) {
    int u, v, w;
    cin >> u >> v >> w, ++deg[v];
    edges[u].emplace_back(v, w);
  }

  Topo();
  cin >> q;

  while (q--) {
    int a, b, u;
    cin >> a >> b >> u;
    int ans = kInf;

    for (const Point &path : paths[u]) {
      ans = std::min(ans, a * path.x + b * path.y);
    }

    cout << ans << "\n";
  }

  return 0;
}