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

int r, c;
int arr[501][501];
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};


int adj[300001][4];
int graph[300001];
vector<int> rev[300001];
int sid;

int visited[300001];
int cycle[300001];
int cid;
vector<int> ci[300001];
int init_dfs(int current) {
    visited[current] = 1;
    int next = graph[current];
    if (visited[next] == -1) {
        visited[current] = -1;
        return -1;
    }
    if (visited[next] == 1) {
        cycle[current] = ++cid;
        ci[cid].push_back(current);
        visited[current] = -1;
        return current != next ? next : -1;
    }
    int r = init_dfs(next);
    visited[current] = -1;
    if (r == -1)
        return -1;
    ci[cid].push_back(current);
    cycle[current] = cid;
    if (current == r)
        return -1;
    return r;
}

int in_cnt;
int in[300001];
void push_adj(int idx) {
    for (int i = 0; i < 4; ++i) {
        int t = adj[idx][i];
        if (t)
            in_cnt += !in[t]++;
    }
}
void pop_adj(int idx) {
    for (int i = 0; i < 4; ++i) {
        int t = adj[idx][i];
        if (t)
            in_cnt -= !--in[t];
    }
}

int dfs(int current) {
    push_adj(current);
    int ret = in_cnt;
    int size = rev[current].size();
    for (int i = 0; i < size; ++i) {
        int next = rev[current][i];
        if (cycle[next])
            continue;
        ret = max(ret, dfs(next));
    }
    pop_adj(current);
    return ret;
}

int track(int idx) {
    int size = ci[idx].size();
    for (int i = 0; i < size; ++i) {
        int p = ci[idx][i];
        push_adj(p);
    }

    int ret = in_cnt;
    for (int i = 0; i < size; ++i) {
        ret = max(ret, dfs(ci[idx][i]));
    }

    for (int i = 0; i < size; ++i) {
        int p = ci[idx][i];
        pop_adj(p);
    }
    return ret;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);

    cin >> r >> c;
    sid = 4;
    for (int i = 1; i <= r; ++i) {
        for (int j = 1; j <= c; ++j) {
            char v;
            cin >> v;
            if (v == '<')
                arr[i][j] = 2;
            else if (v == '>')
                arr[i][j] = 0;
            else if (v == '^')
                arr[i][j] = 3;
            else if (v == 'v')
                arr[i][j] = 1;
            else if (v == '.')
                arr[i][j] = -1;
            else
                arr[i][j] = ++sid;
        }
    }

    for (int i = 1; i <= r; ++i) {
        for (int j = 1; j <= c; ++j) {
            for (int k = 0; k < 4; ++k) {
                int nx = i + dx[k], ny = j + dy[k];
                if (nx <= 0 || ny <= 0 || nx > r || ny > c)
                    continue;
                if (arr[nx][ny] >= 4) {
                    adj[i * c + j][k] = (arr[nx][ny]);
                }
            }

            if (arr[i][j] >= 0 && arr[i][j] < 4) {
                int nx = i + dx[arr[i][j]], ny = j + dy[arr[i][j]];

                if (nx <= 0 || ny <= 0 || nx > r || ny > c ||
                    arr[nx][ny] < 0 || arr[nx][ny] >= 4) {
                    graph[i * c + j] = (0);
                    rev[0].push_back(i * c + j);
                }
                else {
                    graph[i * c + j] = (nx * c + ny);
                    rev[nx * c + ny].push_back(i * c + j);
                }
            }
        }
    }


    for (int i = 1; i <= r; ++i) {
        for (int j = 1; j <= c; ++j) {
            if (arr[i][j] >= 0 && arr[i][j] < 4) {
                if (!visited[i * c + j])
                    init_dfs(i * c + j);
            }
        }
    }

    int ans = 0;
    for (int i = 1; i <= cid; ++i) {
        ans = max(ans, track(i));
    }
    cout << ans;
}