#include <algorithm>
#include <iostream>
#include <vector>
#include <math.h>
#include <set>
#include <map>
#include <string>
#include <stack>
#include <queue>
#include <iomanip>
#include <numeric>
#include <tuple>
#include <bitset>
#include <complex>
#include <unistd.h>
#include <cassert>
#include <cctype>
#include <random>
#define _USE_MATH_DEFINES
#define _GLIBCXX_DEBUG
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> plglg;
typedef pair<double, ll> pdlg;
typedef tuple<int, int, int> tiii;
typedef tuple<ll, ll, ll> tlglglg;
typedef tuple<double, double, double> tddd;
typedef complex<double> xy_t;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
double pi = 3.141592653589793;
ll mod = 1000000007;
int intmax = 2147483647;
int intmin = -2147483648;
ll llmax = 9223372036854775807;
ll llmin = -9223372036854775807;
int iinf = intmax / 8;
ll inf = llmax / 8;
double eps = 1e-11;

bool bo[510][510];

int main() {
    int M, N;
    cin >> M >> N;
    bool res[26];
    fill(res, res + 26, false);
    pii pos[26][2];
    vector<pii> middle[26][2];
    for (int i = 0; i < M; i++) {
        string s;
        cin >> s;
        for (int j = 0; j < N; j++) {
            if (s[j] >= 'A' && s[j] <= 'Z') {
                bo[i][j] = false;
                int mk = s[j] - 'A';
                if (!res[mk]) {
                    pos[mk][0] = pii(i, j);
                    res[mk] = true;
                } else {
                    pos[mk][1] = pii(i, j);
                }
            } else {
                bo[i][j] = true;
            }
        }
    }
    int mk[26];
    for (int i = 0; i < 26; i++) {
        if (res[i]) {
            pii pf = pos[i][0];
            pii ps = pos[i][1];
            if (pf.first == ps.first) {
                mk[i] = 1;
                int lo = min(pf.second, ps.second);
                int hi = max(pf.second, ps.second);
                int x = pf.first;
                if (hi - lo > 1) {
                    for (int j = lo + 1; j < hi; j++) {
                        if (!bo[x][j]) {
                            middle[i][0].push_back(pii(x, j));
                        }
                    }
                } else {
                    res[i] = false;
                }
            } else if (pf.second == ps.second) {
                mk[i] = 1;
                int lo = min(pf.first, ps.first);
                int hi = max(pf.first, ps.first);
                int y = pf.second;
                if (hi - lo > 1) {
                    for (int j = lo + 1; j < hi; j++) {
                        if (!bo[j][y]) {
                            middle[i][0].push_back(pii(j, y));
                        }
                    }
                } else {
                    res[i] = false;
                }
            } else {
                mk[i] = 2;
                if (!bo[pf.first][ps.second]) {
                    middle[i][0].push_back(pii(pf.first, ps.second));
                }
                int lo = min(pf.first, ps.first);
                int hi = max(pf.first, ps.first);
                int y = ps.second;
                for (int j = lo + 1; j < hi; j++) {
                    if (!bo[j][y]) {
                        middle[i][0].push_back(pii(j, y));
                    }
                }
                lo = min(pf.second, ps.second);
                hi = max(pf.second, ps.second);
                int x = pf.first;
                for (int j = lo + 1; j < hi; j++) {
                    if (!bo[x][j]) {
                        middle[i][0].push_back(pii(x, j));
                    }
                }
                if (!bo[ps.first][pf.second]) {
                    middle[i][1].push_back(pii(ps.first, pf.second));
                }
                lo = min(pf.first, ps.first);
                hi = max(pf.first, ps.first);
                y = pf.second;
                for (int j = lo + 1; j < hi; j++) {
                    if (!bo[j][y]) {
                        middle[i][1].push_back(pii(j, y));
                    }
                }
                lo = min(pf.second, ps.second);
                hi = max(pf.second, ps.second);
                x = ps.first;
                for (int j = lo + 1; j < hi; j++) {
                    if (!bo[x][j]) {
                        middle[i][1].push_back(pii(x, j));
                    }
                }
            }
        }
    }
    // for (int i = 0; i < M; i++) {
    //     for (int j = 0; j < N; j++) {
    //         cout << bo[i][j];
    //     }
    //     cout << endl;
    // }
    // for (int i = 0; i < 26; i++) {
    //     cout << res[i] << endl;
    //     int len1 = middle[i][0].size();
    //     for (int j = 0; j < len1; j++) {
    //         cout << middle[i][0][j].first << "-" << middle[i][0][j].second << " ";
    //     }
    //     cout << endl;
    //     int len2 = middle[i][1].size();
    //     for (int j = 0; j < len2; j++) {
    //         cout << middle[i][1][j].first << "-" << middle[i][1][j].second << " ";
    //     }
    //     cout << endl;
    // }
    ll ans = 0;
    for (int i = 0; i < 26; i++) {
        for (int j = 0; j < 26; j++) {
            if (res[j]) {
                bool ok = false;
                if (mk[j] == 1) {
                    if (middle[j][0].size() == 0) {
                        ok = true;
                    }
                } else {
                    if (middle[j][0].size() == 0 || middle[j][1].size() == 0) {
                        ok = true;
                    }
                }
                if (ok) {
                    //cout << j << endl;
                    ans += 2;
                    res[j] = false;
                    pii q = pos[j][0];
                    pii qq = pos[j][1];
                    bo[q.first][q.second] = true;
                    bo[qq.first][qq.second] = true;
                    for (int l = 0; l < 26; l++) {
                        if (res[l]) {
                            int len2a = middle[l][0].size();
                            for (int m = 0; m < len2a; m++) {
                                //cout << m << endl;
                                if (middle[l][0][m] == q || middle[l][0][m] == qq) {
                                    middle[l][0].erase(middle[l][0].begin() + m);
                                    m--;
                                    len2a--;
                                }
                            }
                            int len2b = middle[l][1].size();
                            for (int m = 0; m < len2b; m++) {
                                if (middle[l][1][m] == q || middle[l][1][m] == qq) {
                                    middle[l][1].erase(middle[l][1].begin() + m);
                                    m--;
                                    len2b--;
                                }
                            }
                        }
                    }
                    break;
                }
            }
        }
    }
    cout << ans << endl;
}



Measured memory_bytes: 3464