Problem: Simon loves neatness. So before he goes to bed, Simon wants to complete all chores in the house.

Simon's house looks like a rectangular table consisting of n rows and n columns from above. All rows of the table are numbered from 1 to n from top to bottom. All columns of the table are numbered from 1 to n from left to right. Each cell of the table is a room. Pair (x, y) denotes the room, located at the intersection of the x-th row and the y-th column. For each room we know if the light is on or not there.

Initially Simon is in room (x0, y0). He wants to turn off the lights in all the rooms in the house, and then return to room (x0, y0). Suppose that at the current moment Simon is in the room (x, y). To reach the desired result, he can perform the following steps:

  1. The format of the action is "1". The action is to turn on the light in room (x, y). Simon cannot do it if the room already has light on. 
  2. The format of the action is "2". The action is to turn off the light in room (x, y). Simon cannot do it if the room already has light off. 
  3. The format of the action is "dir" (dir is a character). The action is to move to a side-adjacent room in direction dir. The direction can be left, right, up or down (the corresponding dir is L, R, U or D). Additionally, Simon can move only if he see a light in the direction dir. More formally, if we represent the room, Simon wants to go, as (nx, ny), there shold be an integer k (k > 0), that room (x + (nx - x)k, y + (ny - y)k) has a light. Of course, Simon cannot move out of his house. 



Help Simon, find the sequence of actions that lets him achieve the desired result.

Input

The first line contains three positive integers n, x0, y0 (2 ≤ n ≤ 500, 1 ≤ x0, y0 ≤ n).

Next n lines contain the description of rooms in the house. The i-th line contains n space-separated integers ai1, ai2, ..., ain. If number aij equals zero, then room (i, j) has light off, and if number aij equals one, then room (i, j) has light on. It is guaranteed that at least one room has light on.

Output

If there is no desired sequence of actions, print "NO" (without the quotes). Otherwise, print "YES" (without the quotes) and the description of the required sequence of actions as a string. Note that you do not have to minimize the length of the sequence of actions but you shouldn't use more than 3·106 actions.

Examples

Input

3 1 1
1 0 0
0 1 0
1 0 0


Output

YES
D1R2L2D2UU2


Input

3 1 1
1 0 0
0 1 0
0 0 1


Output

NO

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
  i >> p.first >> p.second;
  return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
  for (auto& v : t) {
    i >> v;
  }
  return i;
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
  o << p.first << ' ' << p.second;
  return o;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
  if (t.empty()) o << '\n';
  for (size_t i = 0; i < t.size(); ++i) {
    o << t[i] << " \n"[i == t.size() - 1];
  }
  return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
template <typename T>
bool in(T a, T b, T c) {
  return a <= b && b < c;
}
unsigned int logceil(long long first) {
  return first ? 8 * sizeof(long long) - __builtin_clzll(first) : 0;
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
  hash<T> t;
  hash<U> u;
  size_t operator()(const pair<T, U>& p) const {
    return t(p.first) ^ (u(p.second) << 7);
  }
};
}  // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
  T r = -1, m;
  while (l <= h) {
    m = (l + h) / 2;
    if (f(m)) {
      l = m + 1;
      r = m;
    } else {
      h = m - 1;
    }
  }
  return r;
}
template <typename F>
double bshd(double l, double h, const F& f, double p = 1e-9) {
  unsigned int r = 3 + (unsigned int)log2((h - l) / p);
  while (r--) {
    double m = (l + h) / 2;
    if (f(m)) {
      l = m;
    } else {
      h = m;
    }
  }
  return (l + h) / 2;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
  T r = -1, m;
  while (l <= h) {
    m = (l + h) / 2;
    if (f(m)) {
      h = m - 1;
      r = m;
    } else {
      l = m + 1;
    }
  }
  return r;
}
template <typename F>
double bsld(double l, double h, const F& f, double p = 1e-9) {
  unsigned int r = 3 + (unsigned int)log2((h - l) / p);
  while (r--) {
    double m = (l + h) / 2;
    if (f(m)) {
      h = m;
    } else {
      l = m;
    }
  }
  return (l + h) / 2;
}
template <typename T>
T gcd(T a, T b) {
  if (a < b) swap(a, b);
  return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
 public:
  vector2() {}
  vector2(size_t a, size_t b, T t = T())
      : vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
 public:
  vector3() {}
  vector3(size_t a, size_t b, size_t c, T t = T())
      : vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
 public:
  vector4() {}
  vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
      : vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
 public:
  vector5() {}
  vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
      : vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
class ENeatness {
 public:
  int N, A, B, X, Y;
  string Sol;
  vector<vector<bool>> L, V;
  vector<int> LOX, HIX, LOY, HIY;
  constexpr char op(char c) {
    switch (c) {
      case 'L':
        return 'R';
      case 'R':
        return 'L';
      case 'D':
        return 'U';
      case 'U':
        return 'D';
      case '1':
        return '2';
      case '2':
        return '1';
      default:
        return 'x';
    }
  }
  void goUp() {
    if (A == 0) return;
    while (B > 0 && L[A][B - 1]) {
      add('L');
      --B;
    }
    while (B < N - 1 && !L[A - 1][B] && L[A][B + 1]) {
      add('R');
      ++B;
    }
    if (L[A - 1][B]) {
      --A;
      add('U');
      goUp();
    }
  }
  void goDown() {
    if (A == N - 1) return;
    while (B > 0 && L[A][B - 1]) {
      add('L');
      --B;
    }
    while (B < N - 1 && !L[A + 1][B] && L[A][B + 1]) {
      add('R');
      ++B;
    }
    if (L[A + 1][B]) {
      ++A;
      add('D');
      goDown();
    }
  }
  void turnOffAndDown() {
    if (A == X) return;
    int b = -1;
    for (int i = 0; i < N; ++i) {
      if (L[A][i] && L[A + 1][i]) {
        b = i;
      }
    }
    while (B > 0 && L[A][B - 1]) {
      add('L');
      --B;
    }
    while (B < N - 1 && L[A][B + 1]) {
      if (B != b) {
        add('2');
        L[A][B] = false;
      }
      add('R');
      ++B;
    }
    if (B != b) {
      add('2');
      L[A][B] = false;
    }
    while (B != b) {
      add('L');
      --B;
    }
    add('2');
    L[A][B] = false;
    add('D');
    ++A;
    turnOffAndDown();
  }
  void turnOffAndUp() {
    int b = Y;
    if (A != X) {
      for (int i = 0; i < N; ++i) {
        if (L[A][i] && L[A - 1][i]) {
          b = i;
        }
      }
    }
    while (B > 0 && L[A][B - 1]) {
      add('L');
      --B;
    }
    while (B < N - 1 && L[A][B + 1]) {
      if (B != b) {
        add('2');
        L[A][B] = false;
      }
      add('R');
      ++B;
    }
    if (B != b) {
      add('2');
      L[A][B] = false;
    }
    while (B != b) {
      add('L');
      --B;
    }
    add('2');
    L[A][B] = false;
    if (A == X) return;
    add('U');
    --A;
    turnOffAndUp();
  }
  void add(char c) {
    if (!Sol.empty() && Sol.back() == op(c))
      Sol.pop_back();
    else
      Sol.push_back(c);
  }
  void bfs(int i, int j) {
    if (V[i][j]) return;
    V[i][j] = true;
    if (!L[i][j]) {
      add('1');
      L[i][j] = true;
      LOX[i] = min(LOX[i], j);
      HIX[i] = max(HIX[i], j);
      LOY[j] = min(LOY[j], i);
      HIY[j] = max(HIY[j], i);
    }
    if (LOX[i] < j) {
      add('L');
      bfs(i, j - 1);
      add('R');
    }
    if (HIX[i] > j) {
      add('R');
      bfs(i, j + 1);
      add('L');
    }
    if (LOY[j] < i) {
      add('U');
      bfs(i - 1, j);
      add('D');
    }
    if (HIY[j] > i) {
      add('D');
      bfs(i + 1, j);
      add('U');
    }
  }
  void solve(istream& cin, ostream& cout) {
    cin >> N >> A >> B;
    L = vector2<bool>(N, N);
    V = vector2<bool>(N, N, false);
    for (auto& l : L) {
      for (int i = 0; i < N; ++i) {
        bool c;
        cin >> c;
        l[i] = c;
      }
    }
    LOX.assign(N, N);
    LOY.assign(N, N);
    HIX.assign(N, -1);
    HIY.assign(N, -1);
    for (int i = 0; i < N; ++i) {
      for (int j = 0; j < N; ++j) {
        if (L[i][j]) {
          LOX[i] = min(LOX[i], j);
          HIX[i] = max(HIX[i], j);
          LOY[j] = min(LOY[j], i);
          HIY[j] = max(HIY[j], i);
        }
      }
    }
    --A;
    --B;
    X = A;
    Y = B;
    bfs(A, B);
    goUp();
    turnOffAndDown();
    goDown();
    turnOffAndUp();
    for (int i = 0; i < N; ++i) {
      for (int j = 0; j < N; ++j) {
        if (L[i][j]) {
          cout << "NO\n";
          return;
        }
      }
    }
    cout << "YES\n" << Sol << '\n';
  }
};
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
  cout.tie(nullptr);
  ENeatness solver;
  std::istream& in(std::cin);
  std::ostream& out(std::cout);
  solver.solve(in, out);
  return 0;
}