#include<bits/stdc++.h>

using namespace std;

using vi = vector<int>;
using pii = pair<int, int>;
using ll = long long;
using vpii = vector<pii>;

using ppiii = pair<pii, int>;

using vb = vector<bool>;
using vvb = vector<vb>;

vi par;

pii operator+(pii a, pii b) {
    return {a.first + b.first, a.second + b.second};
}

pii operator-(pii a, pii b) {
    return {a.first - b.first, a.second - b.second};
}

pii moves[4] = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};
char ops[4] = {'U', 'D', 'R', 'L'};

void dfs(pii u, vvb &vis, vvb &grid, vi &seq) {
    int x, y;
    tie(x, y) = u;
    vis[x][y] = 1;
    for(int d = 0; d < 4; d++) {
        pii v = u + moves[d];
        if(vis[v.first][v.second]) continue;
        if(!grid[v.first][v.second]) continue;
        seq.push_back(d);
        dfs(v, vis, grid, seq);
        seq.push_back(d^1);
    }
}

pii follow(pii u, vi seq, vvb &grid, bool rev) {
    if(rev) {
        reverse(seq.begin(), seq.end());
    }
    for(int op : seq) {
        pii v;
        // if(!rev) {
             v = u + moves[op];
        // } else {
        //     v = u - moves[op];
        // }
        if(!grid[v.first][v.second]) continue;
        u = v;
    }
    return u;
}

const int N = 33;
bool vis[N][N][N][N];
int parop[N][N][N][N];
pair<pii, pii> parnode[N][N][N][N];

void find_path(vvb &grid, pii start2, pii end2) {
    memset(vis, 0, sizeof(vis));
    memset(parop, 0, sizeof(parop));
    memset(parnode, 0, sizeof(parnode));
    queue<pair<pii, pii>> q;
    q.push({start2, end2});
    parop[start2.first][start2.second][end2.first][end2.second] = -1;
    vis[start2.first][start2.second][end2.first][end2.second] = 1;
    while(!q.empty()) {
        pii s, e;
        tie(s, e) = q.front();
        q.pop();
        for(int d = 0; d < 4; d++) {
            pii s1 = s + moves[d];
            if(!grid[s1.first][s1.second]) {
                s1 = s;
            }
            for(int emove = 0; emove <= 1; emove++) {
                pii e1 = e;
                if(emove) {
                    e1 = e - moves[d];
                } else {
                    pii nxt = e + moves[d];
                    if(grid[nxt.first][nxt.second]) {
                        continue;
                    }
                }
                // cerr << s.first << ' ' << s.second << ' ' << e.first << ' ' << e.second << ' ' << s1.first << ' ' << s1.second << ' ' << e1.first << ' ' << e1.second << endl;
                if(!grid[e1.first][e1.second]) {
                    continue;
                }
                if(vis[s1.first][s1.second][e1.first][e1.second]) {
                    continue;
                }
                vis[s1.first][s1.second][e1.first][e1.second] = 1;
                parop[s1.first][s1.second][e1.first][e1.second] = d;
                parnode[s1.first][s1.second][e1.first][e1.second] = {s, e};
                q.push({s1, e1});
            }
        }
    }
}

void solve() {
    int n, m;
    cin >> n >> m;
    vvb grid(n+2, vb(m+2));
    for(int i = 1; i <= n; i++) {
        string s;
        cin >> s;
        for(int j = 0; j < m; j++) {
            grid[i][j+1] = (s[j]-'0');
        }
    }
    
    pii start, end;
    {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;
        start = {x1, y1};
        end = {x2, y2};
    }

    vi tour_seq;
    vvb vis1(n+2, vb(m+2));
    dfs(start, vis1, grid, tour_seq);

    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            if(grid[i][j] && !vis1[i][j]) {
                cout << "-1" << endl;
                return;
            }
        }
    }

    // for(int i : tour_seq) {
    //     cerr << ops[i];
    // }
    // cerr << endl;

    pii start2 = follow(start, tour_seq, grid, false);
    pii end2 = follow(end, tour_seq, grid, true);

    // start -> start2
    // end -> end2
    find_path(grid, start, end);
    assert(vis[start2.first][start2.second][end2.first][end2.second]);
    vi path1;
    pair<pii, pii> cur = {start2, end2};
    while(cur != make_pair(start, end)) {
        // cerr << cur.first.first << ' ' << cur.first.second << ' ' << cur.second.first << ' ' << cur.second.second << endl;
        path1.push_back(parop[cur.first.first][cur.first.second][cur.second.first][cur.second.second]);
        cur = parnode[cur.first.first][cur.first.second][cur.second.first][cur.second.second];
    }
    reverse(path1.begin(), path1.end());

    
    // cerr << end2.first << ' ' << end2.second << endl;


    // cerr << "loop done" << endl;

    find_path(grid, start2, end2);

    pii goodp = {-1, -1};
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            if(vis[i][j][i][j]){
                goodp = {i, j};
            }
        }
    }
    assert(goodp.first != -1);
    // cerr << goodp.first << ' ' << goodp.second << endl;

    vi revseq;
    cur = {goodp, goodp};
    while(cur != make_pair(start2, end2)) {
        // cerr << cur.first.first << ' ' << cur.first.second << ' ' << cur.second.first << ' ' << cur.second.second << endl;
        revseq.push_back(parop[cur.first.first][cur.first.second][cur.second.first][cur.second.second]);
        cur = parnode[cur.first.first][cur.first.second][cur.second.first][cur.second.second];
    }
    reverse(revseq.begin(), revseq.end());
    // cout << tour_seq << revseq << endl;
    string out = "";
    for(int i : path1) {
        out += ops[i];
    }
    // out += "|";
    for(int i : tour_seq) {
        out += ops[i];
    }
    // out += "|";
    for(int i : revseq) {
        out += ops[i];
    }
    // out += "|";
    cout << out;
    reverse(out.begin(), out.end());
    cout << out;
    cout << endl;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    solve();
}