#include <iostream>
#include <algorithm>
#include <string>
#include <queue>
#include <vector>
#include <cstring>
using namespace std;

vector<vector<short>> dist;
vector<vector<pair<short, short>>> parent;
int n, m;

int BFS(const vector<vector<char>> &grid, const vector<vector<bool>> &blocked,
        vector<vector<short>> &dist, vector<vector<pair<short, short>>> &parent)
{
    queue<pair<short, short>> q;
    q.push({1, 1});
    dist[1][1] = 0;
    parent[1][1] = {-1, -1};

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

    while (!q.empty())
    {
        auto [x, y] = q.front();
        q.pop();

        if (x == n && y == m)
            return dist[x][y];

        for (int d = 0; d < 4; d++)
        {
            int nx = x + dx[d];
            int ny = y + dy[d];

            if (nx >= 1 && nx <= n && ny >= 1 && ny <= m &&
                !blocked[nx][ny] && dist[nx][ny] == -1)
            {
                dist[nx][ny] = dist[x][y] + 1;
                parent[nx][ny] = {x, y};
                q.push({nx, ny});
            }
        }
    }

    return -1;
}

int main(void)
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    cin >> n >> m;

    vector<vector<char>> grid(n + 2, vector<char>(m + 2));
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            cin >> grid[i][j];
        }
    }

    vector<vector<bool>> blocked(n + 2, vector<bool>(m + 2, false));

    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            if (grid[i][j] != '.')
            {
                blocked[i][j] = true;
            }
        }
    }

    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            if (grid[i][j] == '^')
            {
                for (int k = i - 1; k >= 1 && grid[k][j] == '.'; k--)
                {
                    blocked[k][j] = true;
                }
            }
            else if (grid[i][j] == 'v')
            {
                for (int k = i + 1; k <= n && grid[k][j] == '.'; k++)
                {
                    blocked[k][j] = true;
                }
            }
            else if (grid[i][j] == '<')
            {
                for (int k = j - 1; k >= 1 && grid[i][k] == '.'; k--)
                {
                    blocked[i][k] = true;
                }
            }
            else if (grid[i][j] == '>')
            {
                for (int k = j + 1; k <= m && grid[i][k] == '.'; k++)
                {
                    blocked[i][k] = true;
                }
            }
        }
    }

    if (blocked[1][1] || blocked[n][m])
    {
        cout << -1 << '\n';
        return 0;
    }

    dist.assign(n + 2, vector<short>(m + 2, -1));
    parent.assign(n + 2, vector<pair<short, short>>(m + 2));

    int pathLength = BFS(grid, blocked, dist, parent);

    if (pathLength == -1)
    {
        cout << -1 << '\n';
    }
    else
    {
        vector<vector<char>> ans = grid;
        int x = n, y = m;
        while (x != -1 && y != -1)
        {
            if (ans[x][y] == '.')
            {
                ans[x][y] = 'X';
            }
            auto [px, py] = parent[x][y];
            x = px;
            y = py;
        }

        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= m; j++)
            {
                cout << ans[i][j];
            }
            cout << '\n';
        }
    }

    return 0;
}