#include<cassert>
#include<set>
#include<map>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int N = 50005, M = 200005 << 1, MOD = 1000000007, BAR = 250;

int inverse(int a) {
	return a == 1 ? a : (long long)(MOD - MOD / a) * inverse(MOD % a) % MOD;
}

int n, m;

set<pair<int, int> > edges;
map<pair<int, int>, int> ets[3];

#define next NEXT

int dgr[N];

int top, head[N], from[M], to[M], next[M], c[3][M];

void addEdge(int u, int v, int c0, int c1, int c2) {
	++dgr[u], ++dgr[v];
	from[top] = u, to[top] = v, next[top] = head[u], c[0][top] = c0, c[1][top] = c1, c[2][top] = c2, head[u] = top++;
	from[top] = v, to[top] = u, next[top] = head[v], c[0][top] = c0, c[1][top] = c1, c[2][top] = c2, head[v] = top++;
}

inline bool isSmall(int u) {
	return dgr[u] <= BAR;
}

inline int calTri(int i, int j, int k) {
	int ret = (((long long)c[1][i] * c[2][j] + (long long)c[2][i] * c[1][j]) % MOD * c[0][k] 
		+ ((long long)c[0][i] * c[2][j] + (long long)c[2][i] * c[0][j]) % MOD * c[1][k] 
		+ ((long long)c[0][i] * c[1][j] + (long long)c[1][i] * c[0][j]) % MOD * c[2][k]) % MOD;
	return ret;
}

int stamp, vis[N], eid[N];

int solveLarge(int u) {
	int ret = 0;
	++stamp;
	for (int i = head[u]; ~i; i = next[i]) {
		int v = to[i];
		vis[v] = stamp;
		eid[v] = i;
	}
	int sum[3] = {0, 0, 0};
	for (int i = 0; i < top; i += 2) {
		int v = from[i], w = to[i];
		if (vis[v] == stamp && vis[w] == stamp) {
			int cntSmall = isSmall(v) + isSmall(w),
				delta = calTri(eid[v], i, eid[w] ^ 1);
			if ((sum[cntSmall] += delta) >= MOD) {
				sum[cntSmall] -= MOD;
			}
		}
	}
	ret = ((long long)sum[0] * inverse(3) + (long long)sum[1] * inverse(2) + (long long)sum[2]) % MOD;
	return ret;
}

int solveSmall(int u) {
	int ret = 0;
	++stamp;
	for (int i = head[u]; ~i; i = next[i]) {
		int v = to[i];
		if (isSmall(v)) {
			vis[v] = stamp;
			eid[v] = i;
			for (int j = head[v]; ~j; j = next[j]) {
				int w = to[j];
				if (vis[w] == stamp) {
					if ((ret += calTri(i, j, eid[w] ^ 1)) >= MOD) {
						ret -= MOD;
					}
				}
			}
		}
	}
	ret = (long long)ret * inverse(3) % MOD;
	return ret;
}

int main() { 
	memset(head, -1, sizeof(head));
	scanf("%d%d", &n, &m);
	for (int i = 0; i < m; ++i) {
		int u, v, w, c = -1;
		char s[2];
		scanf("%d%d%d%s", &u, &v, &w, s);
		--u, --v;
		if (s[0] == 'R') {
			c = 0;
		} else if (s[0] == 'G') {
			c = 1;
		} else if (s[0] == 'B') {
			c = 2;
		}
		if (u > v) {
			swap(u, v);
		}
		(ets[c][make_pair(u, v)] += w) %= MOD;
		edges.insert(make_pair(u, v));
	}
	for (set<pair<int, int> >::iterator it = edges.begin(); it != edges.end(); ++it) {
		addEdge((*it).first, (*it).second, ets[0][*it], ets[1][*it], ets[2][*it]);
	}
	int ans = 0;
	for (int i = 0; i < n; ++i) {
		if (isSmall(i)) {
			(ans += solveSmall(i)) %= MOD;
		} else {
			(ans += solveLarge(i)) %= MOD;
		}
	}
	printf("%d\n", ans);
	return 0;
}