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

const int MAXN = 20005; // 2*N do có thể chênh lệch chỉ số
int parent[MAXN];
int diff[MAXN]; // diff[v] = P[v] xor P[parent[v]]
int n, k;

int find(int u) {
    if (parent[u] == u) return u;
    int root = find(parent[u]);
    diff[u] ^= diff[parent[u]]; // Path compression
    return parent[u] = root;
}

bool merge(int u, int v, int w) { // w = 0 if P[u] == P[v], 1 if P[u] != P[v]
    int root_u = find(u);
    int root_v = find(v);
    if (root_u == root_v) {
        // Check consistency
        return (diff[u] ^ diff[v]) == w;
    }
    parent[root_u] = root_v;
    // diff[root_u] ^ diff[v] ^ diff[u] = w (cần P[root_u] xor P[root_v] = w)
    // P[root_u] xor P[u] = diff[u] => P[root_u] = P[u] xor diff[u]
    // P[root_v] xor P[v] = diff[v] => P[root_v] = P[v] xor diff[v]
    // P[root_u] xor P[root_v] = w
    // (P[u] xor diff[u]) xor (P[v] xor diff[v]) = w
    // P[u] xor P[v] = w xor diff[u] xor diff[v]
    // diff[root_u] = P[root_u] xor P[root_v] = w xor diff[u] xor diff[v]
    diff[root_u] = w ^ diff[u] ^ diff[v];
    return true;
}

bool check(int target_pn, vector<tuple<int,int,int>>& queries, int type) {
    // type 0: check if we can satisfy even constraints with P[N] = target_pn
    // type 1: check if we can satisfy odd constraints with P[N] = target_pn
    // Actually, we just need to check disjoint sets for consistency.
    // But we must consider P[0] and P[N].
    // P[0] = 0.
    // P[N] = target_pn.
    // So we add constraint P[0] ^ P[N] = target_pn.
    // Also, we only add constraints of the specific type.

    // Reset DSU
    for(int i=0; i<=2*n; ++i) {
        parent[i] = i;
        diff[i] = 0;
    }

    // Add base constraint P[0] vs P[N]
    if (!merge(0, N, target_pn)) return false;

    for (auto& q : queries) {
        int u = get<0>(q);
        int v = get<1>(q);
        int w = get<2>(q);
        if (w == type) {
            if (!merge(u, v, (type == 0 ? 0 : 1))) return false;
        }
    }
    return true;
}

int main() {
    cin >> n >> k;
    vector<tuple<int, int, int>> queries;
    int even_count = 0;
    for (int i = 0; i < k; ++i) {
        int u, v;
        string s;
        cin >> u >> v >> s;
        // Map: P[u-1] vs P[v]
        // DSU indices: 0 to N
        // Let's use u-1 and v for P indices
        queries.push_back({u-1, v, (s == "odd" ? 1 : 0)});
        if (s == "even") even_count++;
    }

    // Case 1: P[N] = 0 (Total sum is even)
    // Then all 'even' queries must be true (P[v] == P[u-1] => w=0)
    // All 'odd' queries must be false (P[v] != P[u-1] => w=1)
    // Wait, if P[N]=0, we don't need to satisfy 'odd' queries? 
    // The problem says: "find the last answer that doesn't contradict"
    // If P[N]=0, then all 'even' answers are correct. 
    // So we only need to check if 'even' constraints are consistent.
    // If they are, then answer is total 'even' count.

    // Case 2: P[N] = 1 (Total sum is odd)
    // Then all 'odd' answers are correct.
    // So we only need to check if 'odd' constraints are consistent.
    // If they are, answer is 0.

    // Actually, the logic is:
    // We need to find a valid assignment of P values.
    // If P[N] = 0, then all 'even' queries must be satisfied. 'Odd' queries can be unsatisfied.
    // If P[N] = 1, then all 'odd' queries must be satisfied.

    // Check Case 1: P[N] = 0
    bool possible_even = true;
    // Reset and build graph with 'even' constraints + P[0]=0, P[N]=0
    for(int i=0; i<=2*n; ++i) { parent[i]=i; diff[i]=0; }
    if (!merge(0, n, 0)) possible_even = false;
    for (auto& q : queries) {
        int u = get<0>(q);
        int v = get<1>(q);
        int w = get<2>(q);
        if (w == 0) { // even constraint
            if (!merge(u, v, 0)) { possible_even = false; break; }
        }
    }

    if (possible_even) {
        cout << even_count << endl;
        return 0;
    }

    // Check Case 2: P[N] = 1
    bool possible_odd = true;
    for(int i=0; i<=2*n; ++i) { parent[i]=i; diff[i]=0; }
    if (!merge(0, n, 1)) possible_odd = false;
    for (auto& q : queries) {
        int u = get<0>(q);
        int v = get<1>(q);
        int w = get<2>(q);
        if (w == 1) { // odd constraint
            if (!merge(u, v, 1)) { possible_odd = false; break; }
        }
    }

    if (possible_odd) {
        cout << 0 << endl;
    } else {
        // Problem implies there is a solution. 
        // If neither works, something is wrong or K=0.
        cout << even_count << endl; // Default
    }

    return 0;
}

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

int parent[20005], diff[20005];

int find(int u) {
    if (parent[u] == u) return u;
    int r = find(parent[u]);
    diff[u] ^= diff[parent[u]];
    return parent[u] = r;
}

bool unite(int u, int v, int w) {
    int ru = find(u), rv = find(v);
    if (ru == rv) return (diff[u] ^ diff[v]) == w;
    parent[ru] = rv;
    diff[ru] = w ^ diff[u] ^ diff[v];
    return true;
}

int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    int n, k; cin >> n >> k;
    vector<tuple<int, int, int>> qs;
    int cnt_even = 0;
    for (int i = 0; i < k; ++i) {
        int u, v; string s; cin >> u >> v >> s;
        int w = (s == "odd");
        qs.push_back({u - 1, v, w});
        if (s == "even") cnt_even++;
    }

    // Check if P[N] = 0 is possible (All 'even' answers correct)
    bool ok0 = true;
    for (int i = 0; i <= 2 * n; ++i) parent[i] = i, diff[i] = 0;
    if (!unite(0, n, 0)) ok0 = false;
    for (auto& q : qs) {
        if (get<2>(q) == 0 && !unite(get<0>(q), get<1>(q), 0)) { ok0 = false; break; }
    }
    if (ok0) { cout << cnt_even; return 0; }

    // Check if P[N] = 1 is possible (All 'odd' answers correct)
    for (int i = 0; i <= 2 * n; ++i) parent[i] = i, diff[i] = 0;
    if (!unite(0, n, 1)) return 0;
    for (auto& q : qs) {
        if (get<2>(q) == 1 && !unite(get<0>(q), get<1>(q), 1)) { cout << 0; return 0; }
    }
    cout << 0;
    return 0;
}