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

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;

    vector<array<short, 3>> A, B, P, C;
    for (short i = 0; i < n; i++) {
        char tmp; cin >> tmp;
        for (short j = 0; j < n; j++)
            for (short k = 0; k < n; k++) {
                char ch;
                cin >> ch;
                if (ch == 'B') B.push_back({i, j, k});
                else if (ch == 'A') A.push_back({i, j, k});
                else if (ch == 'P') P.push_back({i, j, k});
                else if (ch == 'C') C.push_back({i, j, k});
            }

        }

    vector<array<short, 3>> dirs;
    for (short di = 0; di < n; di++) {
        for (short dj = (di > 0 ? -(n - 1) : 0); dj < n; dj++) {
            for (short dk = ((di > 0 || dj > 0) ? -(n - 1) : 0); dk < n; dk++) {
                if (!di && !dj && !dk) continue;
                int g = gcd(abs(di), gcd(abs(dj), abs(dk)));
                if (g == 1) dirs.push_back({di, dj, dk});
            }
        }
    }

    long long ans = 0;
    const long long X = 10LL * n * n * n * n;  // large enough multiplier
        unordered_map<int, int> planes;
        unordered_map<long long, int> proj;
    for (auto d : dirs) {
        int ll = d[0] * d[0] + d[1] * d[1] + d[2] * d[2];

        planes.clear(),proj.clear();

        for (auto p : B) {
            int dot = d[0] * p[0] + d[1] * p[1] + d[2] * p[2];
            planes[dot * 2]++;
        }
        for (auto p : C) {
            int dot = d[0] * p[0] + d[1] * p[1] + d[2] * p[2];
            planes[dot * 2 + 1]++;
        }

        auto projKey = [&](array<short, 3> p, int dot) -> long long {
            long long a = 1LL * ll * p[0] - 1LL * d[0] * dot;
            long long b = 1LL * ll * p[1] - 1LL * d[1] * dot;
            long long c = 1LL * ll * p[2] - 1LL * d[2] * dot;
            return a * X * X + b * X + c;
        };

        for (auto p : A) {
            int dot = d[0] * p[0] + d[1] * p[1] + d[2] * p[2];
            auto it = planes.find(dot * 2);
            if (it == planes.end()) continue;
            proj[projKey(p, dot) * 2] += it->second;
        }
        for (auto p : P) {
            int dot = d[0] * p[0] + d[1] * p[1] + d[2] * p[2];
            auto it = planes.find(dot * 2 + 1);
            if (it == planes.end()) continue;
            proj[projKey(p, dot) * 2 + 1] += it->second;
        }

        for (auto &[key, BA] : proj) {
            if ((key & 1) == 0) {
                auto it = proj.find(key + 1);
                if (it != proj.end()) ans += 1LL * BA * it->second;
            }
        }
    }

    cout << ans << '\n';
    return 0;
}