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>
using namespace std;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const int maxn = 2000;
const int maxx = 1790;
const int minx = 210;
const int x_shft = 1000, y_shft = x_shft;
bool A[maxn][maxn];
bool used[maxn][maxn];
pair<int, int> Q[maxn * maxn];
pair<int, int> P[maxn][maxn];
vector<pair<int, int> > tree;
string move_to(int sx, int sy, int fx, int fy) {
  memset(used, false, sizeof(used));
  used[sx][sy] = true;
  int l = 0, r = 0;
  Q[0] = make_pair(sx, sy);
  while (l <= r) {
    int x = Q[l].first, y = Q[l++].second;
    if (x == fx && y == fy) {
      break;
    }
    for (int i = 0; i < 4; ++i) {
      int sx = x + dx[i];
      int sy = y + dy[i];
      if (sx < 0 || sy < 0 || sx >= maxn || sy >= maxn || A[sx][sy] ||
          used[sx][sy]) {
        continue;
      }
      used[sx][sy] = true;
      P[sx][sy] = make_pair(x, y);
      Q[++r] = make_pair(sx, sy);
    }
  }
  string res;
  int x = fx, y = fy;
  while (used[fx][fy] && (x != sx || y != sy)) {
    int px = P[x][y].first, py = P[x][y].second;
    res += px < x ? 'R' : (px > x ? 'L' : (py < y ? 'U' : 'D'));
    x = px;
    y = py;
  }
  reverse(res.begin(), res.end());
  return res;
}
string shadow_move(int &x, int &y, string act) {
  string res;
  for (int i = 0; i < (int)act.size(); ++i) {
    switch (act[i]) {
      case 'L':
        if (!A[x - 1][y]) {
          --x;
          res += 'L';
        }
        break;
      case 'R':
        if (!A[x + 1][y]) {
          ++x;
          res += 'R';
        }
        break;
      case 'U':
        if (!A[x][y + 1]) {
          ++y;
          res += 'U';
        }
        break;
      case 'D':
        if (!A[x][y - 1]) {
          --y;
          res += 'D';
        }
        break;
    }
  }
  return res;
}
void solve1(int vx, int vy, int sx, int sy) {
  string acts = move_to(vx, vy, maxx, maxx);
  string res = acts;
  shadow_move(sx, sy, acts);
  vx = maxx;
  vy = maxx;
  int ix = 1, iy = 1;
  if (vx < sx) {
    acts = move_to(vx, vy, minx, vy);
    vx = minx;
    res += acts;
    shadow_move(sx, sy, acts);
    ix = -1;
  }
  if (vy < sy) {
    acts = move_to(vx, vy, vx, minx);
    vy = minx;
    res += acts;
    shadow_move(sx, sy, acts);
    iy = -1;
  }
  int px = -ix * 100500, py = -iy * 100500;
  for (int i = 0; i < (int)tree.size(); ++i) {
    if (ix * tree[i].first > ix * px ||
        (tree[i].first == px && iy * tree[i].second > iy * py)) {
      px = tree[i].first;
      py = tree[i].second;
    }
  }
  acts = move_to(sx, sy, px, py + iy);
  sx = px;
  sy = py + iy;
  shadow_move(vx, vy, acts);
  res += acts;
  res += move_to(vx, vy, vx, py + iy);
  vy = py + iy;
  acts = move_to(sx, sy, px + ix, py);
  sx = px + ix;
  sy = py;
  shadow_move(vx, vy, acts);
  res += acts;
  res += move_to(vx, vy, px + ix, vy);
  vx = px + ix;
  cout << res << endl;
  assert(vx == sx && vy == sy);
}
void solve2(int vx, int vy, int sx, int sy) {
  string acts = move_to(vx, vy, sx, sy);
  string res = acts;
  while (vx != sx || vy != sy) {
    vx = sx;
    vy = sy;
    acts = shadow_move(sx, sy, acts);
    res += acts;
    assert((int)res.size() < 1000 * 1000);
  }
  cout << res << endl;
}
int main() {
  int vx, vy, sx, sy, m;
  cin >> vx >> vy >> sx >> sy >> m;
  vx += x_shft;
  vy += y_shft;
  sx += x_shft;
  sy += y_shft;
  for (int i = 0; i < m; ++i) {
    int x, y;
    cin >> x >> y;
    tree.push_back(make_pair(x + x_shft, y + y_shft));
    A[x + x_shft][y + y_shft] = true;
  }
  if (!m || !move_to(vx, vy, sx, sy).size()) {
    cout << "-1\n";
    return 0;
  }
  if (move_to(vx, vy, maxx, maxx).size()) {
    solve1(vx, vy, sx, sy);
  } else {
    solve2(vx, vy, sx, sy);
  }
  return 0;
}