#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
using ii = pair<int, int>;
using vii = vector<ii>;
using l = long long;
using vl = vector<l>;
using vvl = vector<vl>;
using ll = pair<l, l>;
using vll = vector<ll>;
using vvll = vector<vll>;
using lu = unsigned long long;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
const int INF = numeric_limits<int>::max();
const double EPS = 1e-10;
const l e5 = 100000, e6 = 1000000, e7 = 10000000, e9 = 1000000000;
const bool enable_log = false;
struct VoidStream {
  void operator&(std::ostream&) {}
};
struct node;
using pnode = shared_ptr<node>;
struct edge {
  pnode from, to;
  l d;
};
struct node {
  l x, y;
  edge back;
  vector<edge> children;
  l count;
  bool on;
  vl ds;
};
const string letters = "ULDR";
vector<set<l>> rows, cols;
pnode add(pnode from, l x, l y, l d) {
  auto to = make_shared<node>();
  edge e;
  e.from = from;
  e.to = to;
  e.d = d;
  to->x = x;
  to->y = y;
  to->count = 0;
  to->back.from = to;
  to->back.to = from;
  to->back.d = (d + 2) % 4;
  for (l i = 0; i < 4; i++)
    if (i != to->back.d) to->ds.emplace_back(i);
  to->on = rows[x].erase(y);
  cols[y].erase(x);
  from->children.emplace_back(e);
  from->count++;
  return to;
}
string go(edge& e) {
  l n = abs(e.from->x - e.to->x) + abs(e.from->y - e.to->y);
  string s = "";
  for (l i = 0; i < n; i++) s += letters[e.d];
  return s;
}
void dfs(pnode u) {
  for (auto d : u->ds) {
    switch (d) {
      case 0: {
        l y = u->y;
        if (cols[y].empty()) continue;
        l to = *(cols[y].begin());
        for (l x = u->x - 1; x >= to; x--) {
          if (rows[x].empty()) continue;
          dfs(add(u, x, y, d));
          break;
        }
        break;
      }
      case 1: {
        l x = u->x;
        if (rows[x].empty()) continue;
        l to = *(rows[x].begin());
        for (l y = u->y - 1; y >= to; y--) {
          if (cols[y].empty()) continue;
          dfs(add(u, x, y, d));
          break;
        }
        break;
      }
      case 2: {
        l y = u->y;
        if (cols[y].empty()) continue;
        l to = *(cols[y].rbegin());
        for (l x = u->x + 1; x <= to; x++) {
          if (rows[x].empty()) continue;
          dfs(add(u, x, y, d));
          break;
        }
        break;
      }
      case 3: {
        l x = u->x;
        if (rows[x].empty()) continue;
        l to = *(rows[x].rbegin());
        for (l y = u->y + 1; y <= to; y++) {
          if (cols[y].empty()) continue;
          dfs(add(u, x, y, d));
          break;
        }
        break;
      }
    }
  }
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  l n, x0, y0;
  while (cin >> n >> x0 >> y0) {
    x0--;
    y0--;
    rows.clear();
    rows.resize(n);
    cols.clear();
    cols.resize(n);
    vvl rooms(n, vl(n));
    for (l i = 0; i < n; i++)
      for (l j = 0; j < n; j++) {
        cin >> rooms[i][j];
        if (rooms[i][j] == 0) continue;
        rows[i].emplace(j);
        cols[j].emplace(i);
      }
    auto rs = rows, cs = cols;
    pnode root = make_shared<node>();
    root->x = x0;
    root->y = y0;
    root->on = rows[x0].erase(y0);
    cols[y0].erase(x0);
    root->ds = {0, 1, 2, 3};
    dfs(root);
    bool ok = true;
    for (auto& r : rows) ok = ok and r.empty();
    if (ok) {
      cout << "YES\n";
      string answer = "";
      auto u = root;
      while (true) {
        auto& r = rooms[u->x][u->y];
        if (u->children.empty()) {
          if (u->on) {
            r--;
            if (r == 0) answer += '2';
          }
          if (u == root) break;
          answer += go(u->back);
          u = u->back.to;
          continue;
        }
        if (not u->on) {
          if (r == 0) answer += '1';
          r++;
          u->on = true;
        }
        auto e = u->children.back();
        u->children.pop_back();
        answer += go(e);
        u = e.to;
      }
      cout << answer << '\n';
    } else {
      cout << "NO\n";
    }
  }
}
