#include "bits/extc++.h"

using namespace std;

template <typename T, typename... U>
void dbgh(const T& t, const U&... u) {
    cerr << t;
    ((cerr << " | " << u), ...);
    cerr << endl;
}

#ifdef DEBUG
#define dbg(...)                                           \
    cerr << "L" << __LINE__ << " [" << #__VA_ARGS__ << "]" \
         << ": ";                                          \
    dbgh(__VA_ARGS__)
#else
#define cerr   \
    if (false) \
    cerr
#define dbg(...)
#endif

#define endl "\n"
#define long int64_t
#define sz(x) int(std::size(x))

using A = array<array<int, 3>, 3>;

map<pair<int, A>, bool> memo;

bool dp(int ind, A arr) {
    auto [it, inserted] = memo.insert({{ind, arr}, false});
    bool& ans = it->second;
    if (!inserted) {
        return ans;
    }
    for (int i = 0; i < 3; i++) {
        if (arr[ind][i]) {
            arr[ind][i]--;
            ans |= !dp(i, arr);
            arr[ind][i]++;
        }
    }
    return ans;
}

A norm(A arr) {
    for (int i = 0; i < 3; i++) {
        arr[i][i] %= 2;
    }
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < i; j++) {
            int sub = min(arr[i][j], arr[j][i]);
            arr[i][j] -= sub;
            arr[j][i] -= sub;
        }
    }
    {
        int sub = min({arr[0][1], arr[1][2], arr[2][0]});
        sub = max(0, sub - 2);
        sub &= ~1;
        arr[0][1] -= sub;
        arr[1][2] -= sub;
        arr[2][0] -= sub;
    }
    {
        int sub = min({arr[1][0], arr[2][1], arr[0][2]});
        sub = max(0, sub - 2);
        sub &= ~1;
        arr[1][0] -= sub;
        arr[2][1] -= sub;
        arr[0][2] -= sub;
    }
    return arr;
}

bool solve(int u, A arr) {
    return dp(u, norm(arr));
}

void solve() {
    int n;
    cin >> n;
    string iarr[n];
    for (auto& a : iarr) {
        cin >> a;
    }
    vector<pair<int, int>> arr;
    {
        vector<char> v;
        for (auto& a : iarr) {
            v.push_back(a[0]);
            v.push_back(a.back());
        }
        sort(begin(v), end(v));
        v.erase(unique(begin(v), end(v)), end(v));

        auto comp = [&](char c) -> int {
            return int(lower_bound(begin(v), end(v), c) - begin(v));
        };

        for (auto& a : iarr) {
            arr.emplace_back(comp(a[0]), comp(a.back()));
        }
    }

    A carr {};
    for (auto& [x, y] : arr) {
        carr[x][y]++;
    }

    int cache[3][3];
    memset(cache, -1, sizeof(cache));

    auto go = [&](int x, int y) -> bool {
        int& ans = cache[x][y];
        if (ans != -1) {
            return ans;
        }

        carr[x][y]--;
        ans = !solve(y, carr);
        carr[x][y]++;
        return ans;
    };

    int ans = 0;
    for (auto& [x, y] : arr) {
        ans += go(x, y);
    }
    cout << ans << endl;
}

int main() {
    cin.tie(nullptr);
    cin.exceptions(ios::failbit);
    ios_base::sync_with_stdio(false);
    solve();
}