#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
#define PB push_back
#define MP make_pair
#define A first
#define B second
#define SZ(x) int(x.size())
#define FR(i, a, b) for (int i = (a); i < (b); ++i)
#define FOR(i, n) FR(i, 0, n)
const int M = 1000000007;
mt19937_64 rnd(chrono::steady_clock::now().time_since_epoch().count());

int r, c;
vector<string> s;

bool starting(int t) {
    int a = t / c;
    int b = t % c;
    return (s[a][b] != '#' && s[a][b] != '.');
}

int nei(int t) {
    int a = t / c;
    int b = t % c;
    if (s[a][b] == '<' && b > 0 && starting(t - 1)) return t - 1;
    if (s[a][b] == '>' && b < c - 1 && starting(t + 1)) return t + 1;
    if (s[a][b] == '^' && a > 0 && starting(t - c)) return t - c;
    if (s[a][b] == 'v' && a < r - 1 && starting(t + c)) return t + c;
    return -1;
}

vector<int> view(int t) {
    int a = t / c;
    int b = t % c;
    auto ok = [&](int a, int b) {
        return (a >= 0 && b >= 0 && a < r && b < c);
    };
    vector<pair<int, int>> dir = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    vector<int> ans;
    for (auto [x, y] : dir) {
        if (ok(a + x, b + y) && s[a + x][b + y] == '#') ans.PB((a + x) * c + b + y);
    }
    return ans;
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cin >> r >> c;
    s.resize(r);
    FOR(i, r) cin >> s[i];
    vector<int> vis(r * c + 1);
    vector<int> pa(r * c + 1, -1);
    vector<vector<int>> cycle;
    int cnt = 0;
    FOR(i, r * c) {
        if (!starting(i) || vis[i]) continue;
        cnt++;
        function<void(int)> dfs1 = [&](int u) {
            vis[u] = cnt;
            auto ne = nei(u);
            if (ne == -1) return;
            if (vis[ne] > 0 && vis[ne] < cnt) return;
            if (vis[ne] == 0) {
                pa[ne] = u;
                dfs1(ne);
                return;
            }
            // cycle
            int cur = u;
            cycle.PB({u});
            while (true) {
                cur = pa[cur];
                cycle.back().PB(cur);
                if (cur == ne) break;
            }
            sort(cycle.back().begin(), cycle.back().end());
        };
        dfs1(i);
    }

    vector<int> node(r * c, -1);
    for (auto c : cycle) {
        for (auto cc : c) {
            node[cc] = c[0];
        }
    }
    FOR(i, r * c) {
        if (!starting(i)) continue;
        if (node[i] != -1) continue;
        node[i] = i;
    }

    vector<vector<int>> back_edge(r * c);
    vector<vector<int>> viewpoint(r * c);
    vector<int> degree(r * c);
    FOR(i, r * c) {
        if (!starting(i)) continue;
        int ne = nei(i);
        auto p = view(i);
        for (auto pp : p) viewpoint[node[i]].PB(pp);
        if (ne == -1) continue;
        if (node[ne] == node[i]) continue;
        degree[node[i]]++;
        back_edge[node[ne]].PB(i);
    }

    int final = 0;
    vis.clear();
    vis.resize(r * c, 0);
    FOR(i, r * c) {
        if (!starting(i)) continue;
        // cout << i << ' ' << vis[node[i]] << ' ' << degree[node[i]] << '\n';
        if (vis[node[i]] || degree[node[i]]) continue;
// cout << i << '\n';
        vector<int> maintain(r * c);
        int counter = 0;
        function<void(int)> dfs2 = [&](int u) {
            vis[u] = 1;
            for (auto pp : viewpoint[u]) {
                maintain[pp]++;
                if (maintain[pp] == 1) counter++;
            }
            final = max(final, counter);
            for (auto v : back_edge[u]) {
                if (vis[v]) continue;
                dfs2(v);
            }

            for (auto pp : viewpoint[u]) {
                maintain[pp]--;
                if (maintain[pp] == 0) counter--;
            }
        };
        dfs2(i);
    }
    cout << final << '\n';

}