Problem: Princess Vlada enjoys springing in the meadows and walking in the forest. One day — wonderful, sunny day — during her walk Princess found out with astonishment that her shadow was missing! "Blimey!", — she thought and started her search of the shadow in the forest.

Normally the Shadow is too lazy and simply sleeps under the Princess. But at this terrifically hot summer day she got bored of such a dull life, so she decided to play with Vlada.

The forest, where our characters entertain themselves, may be represented as a set of integer cells in the plane, where the Shadow and the Princess can move only up, down, left and right by 1. Some cells (as it happens in decent forests) are occupied by trees. The Shadow and the Princess are not allowed to enter a cell occupied by a tree. Unfortunately, these are the hard times for the forest, so there are very few trees growing here...

At first the Princess was walking within the cell (vx, vy), while the Shadow hid from the Princess in the cell (sx, sy). The Princess, The Shadow and the trees are located in the different cells.

The Shadow is playing with the Princess. As soon as the Princess moves by 1 in some direction, the Shadow simultaneously flies by 1 in the same direction, if it is possible (if the cell to fly to is not occupied by some tree); otherwise, the Shadow doesn't move. The Shadow is very shadowy, so our characters do not interfere with each other.

We say that the Shadow is caught by the Princess if after some move both of them are located in the same cell. Vlada managed to catch her Shadow! Can you?

Input

First line of the input contains the coordinates of the characters vx, vy, sx, sy and the number of trees m (0 ≤ m ≤ 400). The following m lines contain the coordinates of the trees.

All the coordinates are integers between -100 and 100, inclusive. The Princess, The Shadow and the trees are located in the different cells.

Output

If it is impossible for the Princess to catch the Shadow, print "-1" (without quotes).

Otherwise print a sequence of characters "L", "R", "D", "U", corresponding to the Princess's moves, following which she will be able to catch the Shadow at some turn (L — move to the left, R — to the right, U — up, D — down; axis x is directed to the right, y — up).

The number of characters (that is, the number of moves) must not exceed 106. All the Princess's moves should be correct, that is must not lead to the cell where a tree grows. It is allowed for the Princess and the Shadow to occupy the same cell before the last turn.

Examples

Input

0 0 1 0 1
0 1


Output

LLUR


Input

5 0 3 0 8
2 -1
2 0
2 1
3 -1
4 1
4 0
3 1
4 -1


Output

-1


Input

3 2 1 1 3
0 1
1 0
0 0


Output

DLL

Note

Below the pictures for the samples are given (Princess, Shadow and the trees are colored in pink, gray and black correspondingly; the blue dot marks the lattice center).

In the first case the Princess may make two left steps, one step upwards and one right step: <image>

In the following case the Princess cannot catch the Shadow: <image>

In the last sample the Princess may make two left steps and one down step (in any order): <image>

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse3,sse4,popcnt,avx,mmx,abm,tune=native")
using namespace std;
namespace output {
void __(short x) { cout << x; }
void __(unsigned x) { cout << x; }
void __(int x) { cout << x; }
void __(long long x) { cout << x; }
void __(unsigned long long x) { cout << x; }
void __(double x) { cout << x; }
void __(long double x) { cout << x; }
void __(char x) { cout << x; }
void __(const char* x) { cout << x; }
void __(const string& x) { cout << x; }
void __(bool x) { cout << (x ? "true" : "false"); }
template <class S, class T>
void __(const pair<S, T>& x) {
  __(1 ? "(" : ""), __(x.first), __(1 ? ", " : " "), __(x.second),
      __(1 ? ")" : "");
}
template <class T>
void __(const vector<T>& x) {
  __(1 ? "{" : "");
  bool _ = 0;
  for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
  __(1 ? "}" : "");
}
template <class T>
void __(const set<T>& x) {
  __(1 ? "{" : "");
  bool _ = 0;
  for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
  __(1 ? "}" : "");
}
template <class T>
void __(const multiset<T>& x) {
  __(1 ? "{" : "");
  bool _ = 0;
  for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
  __(1 ? "}" : "");
}
template <class S, class T>
void __(const map<S, T>& x) {
  __(1 ? "{" : "");
  bool _ = 0;
  for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
  __(1 ? "}" : "");
}
void pr() { cout << "\n"; }
template <class S, class... T>
void pr(const S& a, const T&... b) {
  __(a);
  if (sizeof...(b)) __(' ');
  pr(b...);
}
}  // namespace output
using namespace output;
const int MN = 404, MM = 125;
int n, i, j, x, y, ds[5 * MM * MM], dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1},
                                    dis[2 * MN][2 * MN], block[2 * MN][2 * MN];
pair<int, int> s, e, tmp;
char dir[] = {'L', 'R', 'D', 'U'};
vector<char> ans;
int fnd(int x) { return ds[x] = ds[x] == x ? x : fnd(ds[x]); }
inline void mv(int id, int dx, int dy) {
  int nx = (!id ? s.first : e.first) + dx,
      ny = (!id ? s.second : e.second) + dy;
  if (nx >= 0 && nx < 2 * MM && ny >= 0 && ny < 2 * MM && block[nx][ny]) return;
  if (!id)
    s = {nx, ny};
  else
    e = {nx, ny};
}
inline void gen(pair<int, int> src) {
  queue<pair<int, int> > q;
  memset(dis, -1, sizeof(dis));
  dis[src.first][src.second] = 0;
  q.push(src);
  while (q.size()) {
    pair<int, int> cur = q.front();
    q.pop();
    for (int k = 0; k < 4; k++) {
      int nx = cur.first + dx[k], ny = cur.second + dy[k];
      if (nx < 0 || nx > 2 * MM || ny < 0 || ny > 2 * MM) continue;
      if (!block[nx][ny] && dis[nx][ny] == -1) {
        dis[nx][ny] = dis[cur.first][cur.second] + 1;
        q.push({nx, ny});
      }
    }
  }
}
inline void trans(int d, int steps) {
  while (steps--) {
    mv(0, dx[d], dy[d]);
    mv(1, dx[d], dy[d]);
    ans.push_back(dir[d]);
  }
}
int main() {
  scanf("%d%d%d%d%d", &s.first, &s.second, &e.first, &e.second, &n);
  s.first += MM, s.second += MM, e.first += MM, e.second += MM;
  for (i = 1; i <= n; i++) {
    scanf("%d%d", &x, &y);
    x += MM, y += MM;
    block[x][y] = 1;
  }
  for (i = 0; i < 2 * MM; i++) {
    for (j = 0; j < 2 * MM; j++) ds[i * (2 * MM) + j] = i * (2 * MM) + j;
  }
  for (i = 0; i < 2 * MM; i++) {
    for (j = 0; j < 2 * MM; j++) {
      if (block[i][j]) continue;
      int id = i * 2 * MM + j;
      for (int k = 0; k < 4; k++) {
        int nx = i + dx[k], ny = j + dy[k];
        if (nx < 0 || nx > 2 * MM || ny < 0 || ny > 2 * MM) continue;
        if (!block[nx][ny]) {
          int ot = nx * 2 * MM + ny;
          if (fnd(id) != fnd(ot)) ds[fnd(id)] = fnd(ot);
        }
      }
    }
  }
  int hm = 2 * MM - 1;
  const int INF = 1500;
  if (fnd(s.first * 2 * MM + s.second) != fnd(e.first * 2 * MM + e.second) ||
      !n)
    printf("-1\n");
  else if (fnd(s.first * 2 * MM + s.second) == fnd(hm * 2 * MM + hm)) {
    gen(s);
    vector<int> op;
    pair<int, int> cur = {hm, hm};
    while (cur != s) {
      for (int k = 0; k < 4; k++) {
        int nx = cur.first + dx[k], ny = cur.second + dy[k];
        if (nx < 0 || nx > 2 * MM || ny < 0 || ny > 2 * MM) continue;
        if (dis[nx][ny] + 1 == dis[cur.first][cur.second]) {
          op.push_back(k ^ 1);
          cur = {nx, ny};
          break;
        }
      }
    }
    reverse(op.begin(), op.end());
    for (auto v : op) {
      mv(0, dx[v], dy[v]);
      mv(1, dx[v], dy[v]);
      ans.push_back(dir[v]);
    }
    op.clear();
    for (i = 0; i < 2 * MM + 10; i++) {
      mv(0, dx[1], dy[1]);
      mv(1, dx[1], dy[1]);
      ans.push_back(dir[1]);
      mv(0, dx[3], dy[3]);
      mv(1, dx[3], dy[3]);
      ans.push_back(dir[3]);
    }
    if (e.first >= 0 && e.first < hm && e.second >= 0 && e.second < hm) {
      gen(e);
      op.clear();
      pair<int, int> cur = {hm, hm};
      while (cur != e) {
        for (int k = 0; k < 4; k++) {
          int nx = cur.first + dx[k], ny = cur.second + dy[k];
          if (nx < 0 || nx > 2 * MM || ny < 0 || ny > 2 * MM) continue;
          if (dis[nx][ny] + 1 == dis[cur.first][cur.second]) {
            op.push_back(k ^ 1);
            cur = {nx, ny};
            break;
          }
        }
      }
      reverse(op.begin(), op.end());
      for (auto v : op) {
        mv(0, dx[v], dy[v]);
        mv(1, dx[v], dy[v]);
        ans.push_back(dir[v]);
      }
    }
    pair<int, int> a = {min(s.first, e.first), min(s.second, e.second)};
    pair<int, int> b = {max(s.first, e.first), max(s.second, e.second)};
    if (e.first < s.first) {
      pair<int, int> cell(-1, -1);
      for (i = 0; i < 2 * MM; i++) {
        for (j = 0; j < 2 * MM; j++) {
          if (block[i][j] && i > cell.first) cell = {i, j};
        }
      }
      int DX = e.first - cell.first, DY = e.second - cell.second,
          DC = s.first - e.first - 1;
      trans(2, DY);
      trans(0, DX + DC);
      trans(1, DX + DC);
      trans(3, DY);
    } else if (e.first > s.first) {
      pair<int, int> cell(10000, 10000);
      for (i = 0; i < 2 * MM; i++) {
        for (j = 0; j < 2 * MM; j++) {
          if (block[i][j] && i < cell.first) cell = {i, j};
        }
      }
      int IDX = INF;
      trans(0, IDX);
      int DX = cell.first - e.first, DY = e.second - cell.second,
          DC = e.first - s.first - 1;
      trans(2, DY);
      trans(1, DX + DC);
      trans(0, DX + DC);
      trans(3, DY);
      trans(1, IDX);
    }
    if (e.second < s.second) {
      pair<int, int> cell(-1, -1);
      for (i = 0; i < 2 * MM; i++) {
        for (j = 0; j < 2 * MM; j++) {
          if (block[i][j] && i > cell.second) cell = {i, j};
        }
      }
      int DX = e.first - cell.first, DY = e.second - cell.second,
          DC = s.second - e.second - 1;
      trans(0, DX);
      trans(2, DY + DC);
      trans(3, DY + DC);
      trans(1, DX);
    } else if (s.second < e.second) {
      pair<int, int> cell(10000, 10000);
      for (i = 0; i < 2 * MM; i++) {
        for (j = 0; j < 2 * MM; j++) {
          if (block[i][j] && i < cell.second) cell = {i, j};
        }
      }
      int IDY = INF;
      trans(2, IDY);
      int DX = e.first - cell.first, DY = cell.second - e.second,
          DC = e.second - s.second - 1;
      trans(0, DX);
      trans(3, DY + DC);
      trans(2, DY + DC);
      trans(1, DX);
      trans(2, IDY);
    }
    for (auto v : ans) printf("%c", v);
    pr();
  } else {
    queue<pair<int, int> > q;
    while (s != e) {
      gen(e);
      for (int k = 0; k < 4; k++) {
        int nx = s.first + dx[k], ny = s.second + dy[k];
        if (nx < 0 || nx > 2 * MM || ny < 0 || ny > 2 * MM) continue;
        if (dis[nx][ny] + 1 == dis[s.first][s.second]) {
          mv(1, dx[k], dy[k]);
          mv(0, dx[k], dy[k]);
          ans.push_back(dir[k]);
          break;
        }
      }
    }
    for (auto v : ans) printf("%c", v);
    pr();
  }
}