#include "bits/stdc++.h"
using namespace std;
const int N = 22;
char grid[N][N][N];
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;
                grid[i][j][k]=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 = -(n-1); di < n; di++) {
        for (short dj = -(n - 1); dj < n; dj++) {
            for (short dk = -(n - 1); 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
    vector<int> data(n*n*20);
    auto planes = data.begin()+n*n*10;
    for (auto d : dirs) {
        int ll = d[0] * d[0] + d[1] * d[1] + d[2] * d[2];
        

        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]++;
        }

        for (auto p : A) {
            int dot = d[0] * p[0] + d[1] * p[1] + d[2] * p[2];
            array<short,3> q = {p[0]+d[0],p[1]+d[1],p[2]+d[2]};
            if(0<=q[0] and q[0]<n and 0<=q[1] and q[1]<n and 0<=q[2] and q[2]<n) {
                if(grid[q[0]][q[1]][q[2]]=='P') {
                    int dot2 = d[0] * q[0] + d[1] * q[1] + d[2] * q[2];
                    ans+=planes[dot*2]*planes[dot2*2+1];
                }
            }
        }
        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]--;
        }
    }

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