#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;

template<typename T>
ostream_iterator<T> oit(const string &s = " "){ return ostream_iterator<T>(cout,s.c_str()); }
inline auto rep(int l, int r) { return views::iota(min(l, r), r); }
inline auto rep(int n) { return rep(0, n); }
inline auto rep1(int l, int r) { return rep(l, r + 1); }
inline auto rep1(int n) { return rep(1, n + 1); }
inline auto per(int l, int r) { return rep(l, r) | views::reverse; }
inline auto per(int n) { return per(0, n); }
inline auto per1(int l, int r) { return per(l, r + 1); }
inline auto per1(int n) { return per(1, n + 1); }
#define A(a) begin(a),end(a)
inline auto len = ranges::ssize;

struct chash {
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};
template<typename T, typename U> using pb_map = gp_hash_table<T, U, chash>;
template<typename T> using pb_set = gp_hash_table<T, null_type, chash>;
#define K first
#define V second

using ll = long long;
using ld = long double;

using vi = vector<int>;
using vii = vector<vector<int>>;
typedef vector<ll> vll;
using pll = pair<ll,ll>;
using pii = pair<int,int>;

constexpr ll NN = 2e5, M = 1000000007, L = 20;


vector<pii> delta = {{1,0},{-1,0},{0,1},{0,-1}};
vector<char> cneed = {'^','v','<','>'};

void run()
{
    int n,m,ans=0; cin >> n >> m;
    vector<string> g(n);
    for(auto &s : g) cin >> s;
    function<int(int,int,int)> dfs=[&](int i,int j,int cur){
        //grab towers
        vector<pii> towers;
        if(g[i][j] != '.' and g[i][j] != '#'){
            for(int ni,nj; int idx : rep(4)){
                auto [di,dj] {delta[idx]};
                char cn = cneed[idx];
                ni=i+di,nj=j+dj;
                if(ni<0 or nj<0 or ni>=n or nj>=m) continue;
                if(g[ni][nj]=='#')
                    cur++,g[ni][nj]='.',towers.emplace_back(ni,nj);
            }
        }

        int best_cur = cur;
        for(int ni,nj; int idx : rep(4)){
            auto [di,dj] {delta[idx]};
            char cn = cneed[idx];
            ni=i+di,nj=j+dj;
            if(ni<0 or nj<0 or ni>=n or nj>=m) continue;
            if(g[ni][nj] != cn) continue;
            if(g[ni][nj] != '#') g[ni][nj] = 'X';
            best_cur = max(best_cur,dfs(ni,nj,cur));
            if(g[ni][nj] != '#') g[ni][nj] = cn;
        }

        //ungrab them
        for(auto [ni,nj] : towers) g[ni][nj]='#';

        ans = max(ans,best_cur);
        return best_cur;
    };
    //outside
    for(int i : rep(n)){
        if(g[i][0]=='<') dfs(i,0,0);
        if(g[i][m-1]=='>') dfs(i,m-1,0);
    }
    for(int j : rep(m)){
        if(g[0][j]=='^') dfs(0,j,0);
        if(g[n-1][j]=='v') dfs(n-1,j,0);
    }

    //land
    for(int i : rep(n)) for(int j : rep(m))
        if(g[i][j] == '.' or g[i][j]=='#') dfs(i,j,0);

    //cycle
    vii done(n,vi(m));

    auto nt = [&](int i,int j){
        if(g[i][j]=='^') return pii{i-1,j};
        if(g[i][j]=='v') return pii{i+1,j};
        if(g[i][j]=='>') return pii{i,j+1};
        if(g[i][j]=='<') return pii{i,j-1};
        assert(false);
    };

    for(int id = 1; int i : rep(n)){
        for(int j : rep(m)){
            if(done[i][j]) continue;
            if(g[i][j] == '.' or g[i][j]=='#') continue;
            pii start = {i,j};
            pii cur = start;
            vector<pii> stk;
            do{
                done[cur.K][cur.V]=id;
                stk.push_back(cur);
                cur = nt(cur.K,cur.V);
            }while( cur.K>=0 and cur.V>=0 and 
                    cur.K<n and cur.V<m and 
                    !done[cur.K][cur.V] and 
                    g[cur.K][cur.V] != '.' and
                    g[cur.K][cur.V] != '#');
            // cout << cur.K << " " << cur.V << endl; exit(0);
            if(cur.K>=0 and cur.K<n and cur.V>=0 and cur.V<m and done[cur.K][cur.V]==id){ //we found the cycle
                auto f = ranges::find(stk,cur); //need to grab all the towers
                int l =  f-stk.begin();
                vector<pii> towers;
                int score = 0;
                for(int k : rep(l,len(stk))){
                    auto [r,c] {stk[k]};
                    for(auto [dr,dc] : delta){
                        int nr=r+dr,nc=c+dc;
                        if(nr<0 or nc<0 or nr>=n or nc>=m) continue;
                        if(g[nr][nc]=='#') 
                            score++,towers.emplace_back(nr,nc),g[nr][nc]='X';
                    }
                }

                dfs(cur.K,cur.V,score);
                for(auto [r,c] : towers) g[r][c]='#';
            }
            
            id++;
        }
    }

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

int main()
{
    //KING OF THE WORLD...... U.W.T.B
    cin.tie(0);
    ios_base::sync_with_stdio(false);
    run();
}