#include <random>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

mt19937_64 mt(1);

int64_t MOD;

class modint {
private:
	int64_t x;
public:
	modint() : x(0) {}
	modint(int64_t x_) : x(x_ >= 0 ? x_ % MOD : (x_ + 1) % MOD + (MOD - 1)) {}
	int64_t get() const { return x; }
	modint& operator+=(const modint& m) { x = (x + m.x) % MOD; return *this; }
	modint& operator-=(const modint& m) { x = (x - m.x + MOD) % MOD; return *this; }
	modint& operator*=(const modint& m) { x = __int128_t(x) * m.x % MOD; return *this; }
	modint operator+(const modint& m) const { return modint(*this) += m; }
	modint operator-(const modint& m) const { return modint(*this) -= m; }
	modint operator*(const modint& m) const { return modint(*this) *= m; }
	modint pow(long long b) const {
		modint res(1), a(*this);
		while (b) {
			if (b & 1) {
				res *= a;
			}
			a *= a;
			b >>= 1;
		}
		return res;
	}
	modint inv() const {
		return pow(MOD - 2);
	}
};

bool isprime(long long x) {
	if (x <= 1) {
		return false;
	}
	for (int i = 2; 1LL * i * i <= x; i++) {
		if (x % i == 0) {
			return false;
		}
	}
	return true;
}

string to_string(const vector<int>& arr) {
	string res = "[";
	for (int i = 0; i < int(arr.size()); i++) {
		if (i != 0) {
			res += ", ";
		}
		res += to_string(arr[i]);
	}
	res += "]";
	return res;
}

int main() {
	// step #1. input
	cin.tie(nullptr);
	ios::sync_with_stdio(false);
	int N, M, Q;
	cin >> N >> M >> Q;
	vector<int> A(N + M, -1), B(N + M, -1), C(N + M, -1);
	for (int i = N; i < N + M; i++) {
		cin >> A[i] >> B[i] >> C[i];
		A[i]--;
		B[i]--;
		C[i]--;
	}
	vector<int> R(Q);
	vector<vector<int> > P(Q);
	for (int i = 0; i < Q; i++) {
		cin >> R[i];
		P[i].resize(R[i]);
		for (int j = 0; j < R[i]; j++) {
			cin >> P[i][j];
			P[i][j]--;
		}
	}

	// step #2. decide prime
	do {
		MOD = 2 * N * (mt() % (1000000000000000 / (2 * N))) + 1;
	} while (!isprime(MOD));
	
	// step #3. decide root
	vector<int> pdiv;
	for (int i = 2; 1LL * i * i <= MOD - 1; i++) {
		if ((MOD - 1) % i == 0) {
			if (isprime(i)) {
				pdiv.push_back(i);
			}
			if (isprime((MOD - 1) / i)) {
				pdiv.push_back((MOD - 1) / i);
			}
		}
	}
	sort(pdiv.begin(), pdiv.end());
	modint root;
	while (true) {
		root = mt() % (MOD - 1) + 1;
		bool f = true;
		for (int i : pdiv) {
			if (modint(root).pow((MOD - 1) / i).get() == 1) {
				f = false;
				break;
			}
		}
		if (f) {
			break;
		}
	}
	modint gen = root.pow((MOD - 1) / (2 * N));

	// step #4. initialize
	vector<modint> h(N + M);
	for (int i = 0; i < N; i++) {
		h[i] = gen.pow(i * 2);
	}
	
	// step #5. simulation
	for (int i = N; i < N + M; i++) {
		h[i] = h[A[i]] + h[C[i]] - h[B[i]];
	}

	// step #6. calculation
	for (int i = 0; i < Q; i++) {
		if ((2 * N) % R[i] != 0) {
			vector<int64_t> q(R[i]);
			for (int j = 0; j < R[i]; j++) {
				q[j] = h[P[i][j]].get();
			}
			cout << (q == vector<int64_t>(R[i], q[0]) ? "Yes\n" : "No\n");
		} else {
			modint center = 0;
			for (int j = 0; j < R[i]; j++) {
				center += h[P[i][j]];
			}
			center *= modint(R[i]).inv();
			vector<int64_t> q1(R[i]), q2(R[i]);
			for (int j = 0; j < R[i]; j++) {
				q1[j] = ((h[P[i][0]] - center) * gen.pow((2 * N) / R[i] * j) + center).get();
				q2[j] = h[P[i][j]].get();
			}
			sort(q1.begin(), q1.end());
			sort(q2.begin(), q2.end());
			cout << (q1 == q2 ? "Yes\n" : "No\n");
		}
	}

	return 0;
}