#include<bits/stdc++.h>
using namespace std ;
typedef long long ll ;
typedef pair < int , int > pii ;
#define fi first
#define se second
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());

const int MAXN = 507 ;

int n , m ;
string a[ MAXN ] ;
pii nxt[ MAXN ][ MAXN ] ;
vector < pii > gr[ MAXN ][ MAXN ] ;

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

bool in_bounds ( int x , int y ) {
    if ( x < 0 || x >= n ) { return false ; }
    if ( y < 0 || y >= m ) { return false ; }
    return true ;
}

bool water ( int x , int y ) {
    if ( a[ x ][ y ] == '.' ) { return false ; }
    if ( a[ x ][ y ] == '#' ) { return false ; }
    return true ;
}

bool spec ( int x , int y ) {
    if ( a[ x ][ y ] == '#' ) { return true ; }
    return false ;
}

int cand ;
int cnt[ MAXN ][ MAXN ] ;

void add ( int x , int y , int coef ) {
    for ( int i = 0 ; i < 4 ; ++ i ) {
        int nx = x + dx[ i ] , ny = y + dy[ i ] ;
        if ( in_bounds ( nx , ny ) == true && spec ( nx , ny ) == true ) {
            cnt[ nx ][ ny ] += coef ;
            if ( cnt[ nx ][ ny ] == 0 && coef == -1 ) { -- cand ; }
            if ( cnt[ nx ][ ny ] == 1 && coef == 1 ) { ++ cand ; }
        }
    }
}

int used[ MAXN ][ MAXN ] ;
bool cycle_part[ MAXN ][ MAXN ] ;
vector < pii > cycle ;
int ans ;

void dfs ( int x , int y ) {
    add ( x , y , 1 ) ;
    ans = max ( ans , cand ) ;
    for ( auto [ nx , ny ] : gr[ x ][ y ] ) {
        if ( in_bounds ( nx , ny ) == true && water ( nx , ny ) == true && cycle_part[ nx ][ ny ] == false ) {
            dfs ( nx , ny ) ;
        }
    }
    add ( x , y , -1 ) ;
}

void expand ( ) {
    for ( auto [ x , y ] : cycle ) {
        add ( x , y , 1 ) ;
        cycle_part[ x ][ y ] = true ;
    }
    ans = max ( ans , cand ) ;
    for ( auto [ x , y ] : cycle ) {
        add ( x , y , -1 ) ;
        dfs ( x , y ) ;
        add ( x , y , 1 ) ;
    }
    for ( auto [ x , y ] : cycle ) {
        add ( x , y , -1 ) ;
    }
}

void solve ( ) {
    cin >> n >> m ;
    for ( int i = 0 ; i < n ; ++ i ) {
        cin >> a[ i ] ;
    }
    for ( int i = 0 ; i < n ; ++ i ) {
        for ( int j = 0 ; j < m ; ++ j ) {
            if ( a[ i ][ j ] == '^' ) {
                nxt[ i ][ j ] = { i - 1 , j } ;
            }
            if ( a[ i ][ j ] == 'v' ) {
                nxt[ i ][ j ] = { i + 1 , j } ;
            }
            if ( a[ i ][ j ] == '<' ) {
                nxt[ i ][ j ] = { i , j - 1 } ;
            }
            if ( a[ i ][ j ] == '>' ) {
                nxt[ i ][ j ] = { i , j + 1 } ;
            }
            if ( water ( i , j ) == true ) { 
                auto [ x , y ] = nxt[ i ][ j ] ;
                if ( in_bounds ( x , y ) == true && water ( x , y ) == true ) {
                    gr[ x ][ y ].push_back ( { i , j } ) ;
                }
            }
        }
    }
    vector < pii > stk ;
    vector < pii > tot ;
    for ( int i = 0 ; i < n ; ++ i ) {
        for ( int j = 0 ; j < m ; ++ j ) {
            if ( water ( i , j ) == false ) { continue ; }
            if ( used[ i ][ j ] != 0 ) { continue ; }
            stk.clear ( ) ; cycle.clear ( ) ; tot.clear ( ) ;
            int x = i , y = j ;
            while ( in_bounds ( x , y ) == true && water ( x , y ) == true && used[ x ][ y ] == 0 ) {
                stk.push_back ( { x , y } ) ; tot.push_back ( { x , y } ) ;
                used[ x ][ y ] = 2 ;
                auto [ nx , ny ] = nxt[ x ][ y ] ;
                x = nx , y = ny ;
            }
            if ( in_bounds ( x , y ) == false || water ( x , y ) == false ) {
                cycle.push_back ( stk.back ( ) ) ;
            }
            else if ( used[ x ][ y ] == 2 ) {
                while ( stk.back ( ) != make_pair ( x , y ) ) {
                    cycle.push_back ( stk.back ( ) ) ;
                    stk.pop_back ( ) ;
                }
                cycle.push_back ( stk.back ( ) ) ;
            }
            expand ( ) ;
            for ( auto [ foox , fooy ] : tot ) {
                used[ foox ][ fooy ] = 1 ;
            }
        }
    }
    cout << ans << "\n" ;
}

int main ( ) {
    ios_base :: sync_with_stdio ( false ) ;
    cin.tie ( NULL ) ;
    int t = 1 ; // cin >> t ; 
    while ( t -- ) { solve ( ) ; }
    return 0 ;
}