#include <stdio.h>
#include <string.h>
#include <math.h>
#include <vector>
#include <array>
#include <algorithm>
#include <unordered_map>
#define getchar getchar_unlocked
#define putchar putchar_unlocked
int rd_op()
{
    char c = getchar();
    while (c < 'A' || c > 'Z')
        c = getchar();
    return (c == 'R') ? 0 : (c == 'G') ? 1 : 2;
}
int rd()
{
    int k = 0, f = 1;
    char c = getchar();
    while (c < '0' || c > '9')
    {
        if (c == '-')
            f = 0;
        c = getchar();
    }
    while (c >= '0' && c <= '9')
    {
        k = (k << 1) + (k << 3) + (c ^ 48);
        c = getchar();
    }
    return f ? k : -k;
}
void wr(int x)
{
    if (x < 0)
        putchar('-'), x = -x;
    if (x > 9)
        wr(x / 10);
    putchar(x % 10 + '0');
}
using namespace std;
typedef long long i64;
const int N = 50010;
const int M = 100010;
const int mod = 1000000007;
int add(int a, int b) { return (a + b >= mod) ? (a + b - mod) : (a + b); }
int mul(int a, int b) { return 1ll * a * b % mod; }

struct edge
{
    int u, v;
    edge(int _u = 0, int _v = 0) : u(_u), v(_v) { if (u > v) std::swap(u, v); }
    bool operator==(const edge& o) const { return (u == o.u) && (v == o.v); }
};
struct edge_hash
{
    size_t operator()(const edge& a) const { return hash<int>()(a.u) * 611953 + hash<int>()(a.v) * 7919; }
};
using unmap = std::unordered_map<edge, std::array<int, 3>, edge_hash>;
const std::array<int, 3> init = {0, 0, 0};
unmap mp;

int n, m, ans;

void add_edge(int u, int v, int w, int ty)
{
    edge info = edge(u, v);
    if (mp.find(info) == mp.end())
        mp[info] = init;
    int ori = mp[info][ty];
    mp[info][ty] = add(ori, w);
}

int from[M << 1], to[M << 1], ecnt;
int deg[N];
std::vector<int> g[N];
int vis[N];

void build_g()
{
    for (unmap::iterator it = mp.begin(); it != mp.end(); ++it)
        from[++ecnt] = it->first.u, to[ecnt] = it->first.v, ++deg[from[ecnt]], ++deg[to[ecnt]];
    for (int i = 1; i <= ecnt; ++i)
    {
        if (deg[from[i]] > deg[to[i]] || (deg[from[i]] == deg[to[i]] && from[i] > to[i]))
            swap(from[i], to[i]);
        g[from[i]].push_back(to[i]);
    }
}

void enumerate_triangles()
{
    for (int i = 1; i <= n; ++i)
    {
        for (int j : g[i])
            vis[j] = 1;
        for (int j : g[i])
            for (int k : g[j])
                if (vis[k])
                {
                    std::array<int, 3> ij = mp[edge(i, j)], jk = mp[edge(j, k)], ki = mp[edge(k, i)];
                    ans = add(ans, mul(ij[0], mul(jk[1], ki[2])));
                    ans = add(ans, mul(ij[0], mul(jk[2], ki[1])));
                    ans = add(ans, mul(ij[1], mul(jk[0], ki[2])));
                    ans = add(ans, mul(ij[1], mul(jk[2], ki[0])));
                    ans = add(ans, mul(ij[2], mul(jk[0], ki[1])));
                    ans = add(ans, mul(ij[2], mul(jk[1], ki[0])));
                }
        for (int j : g[i])
            vis[j] = 0;
    }
}

int main()
{
    n = rd(), m = rd();
    for (int i = 1; i <= m; ++i)
    {
        int u = rd(), v = rd(), w = rd(), ty = rd_op();
        add_edge(u, v, w, ty);
    }
    build_g();
    enumerate_triangles();
    wr(ans);
}