#include <cstdio>
#include <algorithm>
#include <utility>
#include <vector>
using namespace std;
typedef pair<int, int> pii;
constexpr int MAXR = 510;
constexpr int MAXN = MAXR * MAXR;

int R, C;
char terrain[MAXR][MAXR];
int to_node(short x, short y) { return x * (C + 2) + y; }
bool is_land(short x, short y) { return terrain[x][y] == '.' || terrain[x][y] == '#'; }

struct Coord
{
	const short x, y;
	Coord(int x, int y) : x(x), y(y) {}
	Coord operator+(const Coord &o) const { return {x + o.x, y + o.y}; }
	char get_terrain() const { return terrain[x][y]; }
	int to_node() const { return ::to_node(x, y); }
	bool is_land() const { return ::is_land(x, y); }
	Coord move_next() const
	{
		const char cell = terrain[x][y];
		if (cell == '^')
			return {x - 1, y};
		else if (cell == 'v')
			return {x + 1, y};
		else if (cell == '<')
			return {x, y - 1};
		else if (cell == '>')
			return {x, y + 1};
		return {x, y};
	}
};

int terr2node[MAXR][MAXR];
bool visited[MAXN];
bool visiting[MAXN];
bool loopnode[MAXN];
int dfs0(const Coord cell)
{
	if (cell.is_land())
		return -1;
	const int node = cell.to_node();
	if (visiting[node])
	{
		loopnode[node] = true;
		return node;
	}
	if (visited[node])
		return -1;
	visiting[node] = true;

	const int next = dfs0(cell.move_next());
	terr2node[cell.x][cell.y] = (next == -1) ? node : next;
	visiting[node] = false;
	visited[node] = true;
	if (node == next)
		return -1;
	return next;
}

vector<int> sons[MAXN];
vector<int> spots[MAXN];
int active_spots, ans;
int spots_counter[MAXN];
void dfs1(const int node)
{
	for (const int s : spots[node])
	{
		spots_counter[s]++;
		if (spots_counter[s] == 1)
			active_spots++;
	}
	ans = max(ans, active_spots);
	for (const int s : sons[node])
		dfs1(s);
	for (const int s : spots[node])
	{
		spots_counter[s]--;
		if (spots_counter[s] == 0)
			active_spots--;
	}
}

int main()
{
	scanf("%d %d", &R, &C);
	const int TERN = (R + 2) * (C + 2);
	for (int i = 1; i <= R; i++)
		scanf("%s", 1 + terrain[i]);
	fill(terrain[0], terrain[0] + C + 2, '.');
	fill(terrain[R + 1], terrain[R + 1] + C + 2, '.');
	for (int i = 1; i <= R; i++)
		terrain[i][0] = terrain[i][C + 1] = '.';

	for (int i = 0; i < R + 2; i++)
		for (int j = 0; j < C + 2; j++)
			if (is_land(i, j))
				terr2node[i][j] = TERN;
			else if (!visited[to_node(i, j)])
				dfs0({i, j});

	for (int i = 1; i <= R; i++)
		for (int j = 1; j <= C; j++)
			if (!is_land(i, j) && !loopnode[terr2node[i][j]])
			{
				const Coord next_coord = Coord{i, j}.move_next();
				const int next_node = terr2node[next_coord.x][next_coord.y];
				sons[next_node].push_back(to_node(i, j));
			}
	for (int i = 0; i < TERN; i++)
		if (loopnode[i])
			sons[TERN].push_back(i);

	for (int i = 1; i <= R; i++)
		for (int j = 1; j <= C; j++)
		{
			const Coord c = {i, j};
			if (c.is_land())
				continue;
			for (const Coord d : {Coord{0, -1}, {0, 1}, {-1, 0}, {1, 0}})
				if ((c + d).get_terrain() == '#')
					spots[terr2node[c.x][c.y]].push_back((c + d).to_node());
		}
	for (int i = 0; i < TERN; i++)
		if (vector<int> &s = spots[i]; s.size() != 0)
		{
			sort(s.begin(), s.end());
			s.resize(unique(s.begin(), s.end()) - s.begin());
		}

	ans = 0;
	dfs1(TERN);
	printf("%d\n", ans);
	return 0;
}