#pragma GCC optimize("O3")
#pragma GCC optimize ("unroll-loops")
#pragma GCC target("avx,avx2,fma")

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

#define ll long long
#define ld double
typedef complex<ld> point;

const int N = 2000 + 5;

int n, m, cnt, freq[N][N], ans, nodeComp[N][N];
bool vis[N][N];
char grid[N][N];
vector<pair<int, int>> g[N][N], r[N][N];
stack<pair<int, int>> st;
vector<vector<pair<int, int>>> comps;
map<char, int> dir;
vector<int>compsG[N * N];

int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};

/*
dir['>'] = 0
dir['^'] = 2
dir['<'] = 1
dir['v'] = 3
*/

bool isRever(int i, int j) {
    return grid[i][j] != '.' && grid[i][j] != '#';
}

bool isValid(int i, int j) {
    return i < n && j < m && i >= 0 && j >= 0;
}

bool isRoot(int c) {
    if (comps[c].size() > 1) {
        return true;
    }
    auto u = comps[c].back();
    auto x = u.first;
    auto y = u.second;
    return r[x][y].empty();
}

void dfs(int x, int y, int rv) {
    vis[x][y] = true;
    auto &adj = rv ? r[x][y] : g[x][y];
    for (auto &i : adj) {
        auto n_x = i.first;
        auto n_y = i.second;
        if (!vis[n_x][n_y]) {
            dfs(n_x, n_y, rv);
        }
    }
    if (!rv) { 
        st.emplace(x, y);
    } else {
        comps.back().emplace_back(x, y);
        nodeComp[x][y] = comps.size() - 1;
        // cout << x << ' ' << y << ' ' << comps.size() - 1 << '\n';
    }
}

void kosaraju() {
    memset(vis, 0, sizeof(vis));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            if (isRever(i, j) && !vis[i][j]) {
                dfs(i, j, 0);
            }
        }
    }
    memset(vis, 0, sizeof(vis));
    while (!st.empty()) {
        auto cur = st.top();
        st.pop();
        auto x = cur.first;
        auto y = cur.second;
        if (!vis[x][y]) {
            comps.push_back({});
            dfs(x, y, 1);
        }
    }
}

void add(pair<int, int> &u) {
    auto x = u.first;
    auto y = u.second;
    for (int i = 0; i < 4; ++i) {
        auto n_x = x + dx[i];
        auto n_y = y + dy[i];
        if (isValid(n_x, n_y) && grid[n_x][n_y] == '#') {
            if (!freq[n_x][n_y]++) {
                ++cnt;
            }
        }
    }
}

void rem(pair<int, int> &u) {
    auto x = u.first;
    auto y = u.second;
    for (int i = 0; i < 4; ++i) {
        auto n_x = x + dx[i];
        auto n_y = y + dy[i];
        if (isValid(n_x, n_y) && grid[n_x][n_y] == '#') {
            if (!--freq[n_x][n_y]) {
                --cnt;
            }
        }
    }
}

void solve(int c) {
    for (auto &node : comps[c]) {
        add(node);
    }
    // cout << "Component #" << c << ": " << cnt << '\n';
    ans = max(ans, cnt);
    for (auto &i : compsG[c]) {
        // cout << i << " x";
        solve(i);
    }
    for (auto &node : comps[c]) {
        rem(node);
    }
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    dir['>'] = 0;
    dir['^'] = 2;
    dir['<'] = 1;
    dir['v'] = 3;
    cin >> n >> m;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            cin >> grid[i][j];
        }
    }
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            if (isRever(i, j)) {
                auto d = dir[grid[i][j]];
                auto n_x = i + dx[d];
                auto n_y = j + dy[d];
                if (isValid(n_x, n_y) && isRever(n_x, n_y)) {
                    g[n_x][n_y].emplace_back(i, j);
                    r[i][j].emplace_back(n_x, n_y);
                }
            }
        }
    }
    kosaraju();
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            if (isRever(i, j)) {
                auto d = dir[grid[i][j]];
                auto n_x = i + dx[d];
                auto n_y = j + dy[d];
                if (isValid(n_x, n_y) && isRever(n_x, n_y)) {
                    auto c_1 = nodeComp[n_x][n_y];
                    auto c_2 = nodeComp[i][j];
                    // cout << c_1 << ' ' << c_2 << '\n';
                    if (c_1 != c_2) {
                        compsG[c_1].push_back(c_2);
                    }
                }
            }
        }
    }
    for (int c = 0; c < comps.size(); ++c) {
        if (isRoot(c)) {
            solve(c);
        }
    }
    cout << ans << '\n';
    return 0;
}