#include <bits/stdc++.h>
using namespace std;

template <class T> int sz(T&& a) { return int(size(forward<T>(a))); }

template <class T> using vc = vector<T>;
template <class T> using vvc = vc<vc<T>>;

using ll = int64_t;
using vi = vc<int>;

template <class F>
struct ycr {
	F f;
	
	template <class T>
	explicit ycr(T&& f_) : f(forward<T>(f_)) {}

	template <class... Args>
	decltype(auto) operator()(Args&&... args) {
		return f(ref(*this), forward<Args>(args)...);
	}
};
template <class F>
decltype(auto) yc(F&& f) {
	return ycr<decay_t<F>>(forward<F>(f));
}

using D = int;
int sgn(D a) {
	return (a > 0) - (a < 0);
}

struct P {
	D x, y;
	P(D x_ = 0, D y_ = 0) : x(x_), y(y_) {}

	P operator + (const P& o) const { return P(x + o.x, y + o.y); }
	P operator - (const P& o) const { return P(x - o.x, y - o.y); }
};
D cross(const P& a, const P& b) {
	return a.x * b.y - a.y * b.x;
}
D cross(const P& a, const P& b, const P& c) {
	return cross(b - a, c - a);
}

vc<P> lower_hull(vc<P> pts) {
	int n = sz(pts);
	sort(pts.begin(), pts.end(), [&](const P& a, const P& b) -> bool {
		return tie(a.x, a.y) < tie(b.x, b.y);
	});
	vc<P> res;
	for (int i = 0; i < n; res.push_back(pts[i++])) {
		for (; res.size() > 1 && sgn(cross(res.end()[-2], res.end()[-1], pts[i])) <= 0; res.pop_back()) {}
	}
	return res;
}

#define LOCAL true

#if LOCAL
constexpr int L = 3;
#else
constexpr int L = 1010;
#endif

const ll INF = 1e9;

template <class T> void setmin(T& a, const T& b) {
	if (a > b) a = b;
}

int main() {
	ios_base::sync_with_stdio(false), cin.tie(nullptr);
	cout << fixed << setprecision(20);

	int N, M; cin >> N >> M;
	struct edge_t {
		int b, c;
	};
	vector<edge_t> edges(M);
	vector<vector<int>> adj(N);
	for (int e = 0; e < M; e++) {
		int u, v, c; cin >> u >> v >> c; u--, v--;
		assert(u < v);
		edges[e] = {v, c};
		adj[u].push_back(e);
	}

	int Q; cin >> Q;
	struct query_t {
		int a, b;
	};
	vector<query_t> queries(Q);
	vector<vector<int>> queries_at(N);
	for (int q = 0; q < Q; q++) {
		int a, b, x; cin >> a >> b >> x; x--;
		queries[q] = {a, b};
		queries_at[x].push_back(q);
	}

	vector<int> ans(Q, INF);
	
	vector<vector<P>> dp(L);
	dp[0].emplace_back(0, 0);
	for (int x = 0; x < N; x++) {
		auto& cnds = dp[x % L];
		cnds = lower_hull(cnds);

		for (int q : queries_at[x]) {
			const auto& [a, b] = queries[q];
			for (const auto& pt : cnds) {
				setmin(ans[q], a * pt.x + b * pt.y);
			}
		}

		for (int e : adj[x]) {
			const auto& [y, c] = edges[e];
			const int dx = (c == 0 ? 1 : 0);
			const int dy = (c == 0 ? 0 : 1);
			auto& tgt = dp[y % L];
			for (const auto& pt : cnds) {
				tgt.emplace_back(pt.x + dx, pt.y + dy);
			}
		}

		cnds.clear();
	}

	for (int v : ans) {
		cout << v << '\n';
	}
}