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 MAXN = 400;
int x[MAXN], y[MAXN];
inline bool lt(int i, int xx, int yy) {
  return x[i] < xx || (x[i] == xx && y[i] < yy);
}
inline bool gt(int i, int xx, int yy) {
  return x[i] > xx || (x[i] == xx && y[i] > yy);
}
void mysort(int l, int r) {
  if (l < r) {
    int pivot = int((rand() / (1.0 + RAND_MAX)) * (r - l + 1)) + l;
    int xx = x[pivot];
    int yy = y[pivot];
    int i = l;
    int j = r;
    while (1) {
      while (lt(i, xx, yy)) ++i;
      while (gt(j, xx, yy)) --j;
      if (i <= j) {
        swap(x[i], x[j]);
        swap(y[i], y[j]);
        ++i;
        --j;
      } else {
        break;
      }
    }
    mysort(l, j);
    mysort(i, r);
  }
}
bool outside(int xx, int xlo, int xhi) { return xx < xlo || xx > xhi; }
bool outside(int xx, int yy, int xlo, int xhi, int ylo, int yhi) {
  return outside(xx, xlo, xhi) || outside(yy, ylo, yhi);
}
const int MAXSTEPS = 1000000;
char steps[MAXSTEPS + 1];
int dy[] = {1, 0, -1, 0};
int dx[] = {0, 1, 0, -1};
string stepcode = "URDL";
const int OFFSET = 120;
bool board[2 * OFFSET + 1][2 * OFFSET + 1];
int from[2 * OFFSET + 1][2 * OFFSET + 1];
int n;
bool tree(int xx, int yy) {
  pair<int*, int*> p_ = equal_range(x, x + n, xx);
  int p = p_.first - x;
  int q = p_.second - x;
  cerr << "tree: " << xx << ' ' << yy << ' ' << p << ' ' << q << '\n';
  if (p < n && x[p] == xx) {
    int i = lower_bound(y + p, y + q, yy) - y;
    cerr << i << '\n';
    return (i < q && y[i] == yy);
  }
  return false;
}
int main() {
  int vx, vy, sx, sy;
  cin >> vx >> vy >> sx >> sy >> n;
  if (n == 0) {
    puts("-1");
    return 0;
  }
  int orig_vx = vx;
  int orig_vy = vy;
  int orig_sx = sx;
  int orig_sy = sy;
  for (int i = 0; i < n; ++i) {
    cin >> x[i] >> y[i];
  }
  mysort(0, n - 1);
  for (int i = 0; i < n; ++i) {
    cerr << x[i] << ' ' << y[i] << '\n';
  }
  cerr << '\n';
  int xlo = x[0];
  int xhi = x[n - 1];
  int ylo = *min_element(y, y + n);
  int yhi = *max_element(y, y + n);
  int step = 0;
  if (!outside(vx, vy, xlo, xhi, ylo, yhi) ||
      !outside(sx, sy, xlo, xhi, ylo, yhi)) {
    for (int i = 0; i < n; ++i) {
      (board[(x[i]) + OFFSET][(y[i]) + OFFSET]) = 1;
    }
    memset(from, 0xff, sizeof from);
    queue<pair<int, int> > Q;
    Q.push(make_pair(vx, vy));
    (from[(vx) + OFFSET][(vy) + OFFSET]) = 1;
    while (!Q.empty()) {
      pair<int, int> tmp = Q.front();
      Q.pop();
      int u = tmp.first;
      int v = tmp.second;
      for (int d = 0; d < 4; ++d) {
        int r = u + dx[d];
        int c = v + dy[d];
        if (r + OFFSET < 0 || c + OFFSET < 0 || r > OFFSET || c > OFFSET ||
            (from[(r) + OFFSET][(c) + OFFSET]) != -1 ||
            (board[(r) + OFFSET][(c) + OFFSET])) {
          continue;
        }
        (from[(r) + OFFSET][(c) + OFFSET]) = d;
        if (r == sx && c == sy) {
          goto BFS_DONE;
        }
        Q.push(make_pair(r, c));
      }
    }
  BFS_DONE:;
    if ((from[(sx) + OFFSET][(sy) + OFFSET]) == -1) {
      puts("-1");
      return 0;
    }
    vector<int> D;
    int xx = sx;
    int yy = sy;
    while (xx != vx || yy != vy) {
      D.push_back((from[(xx) + OFFSET][(yy) + OFFSET]));
      xx -= dx[D.back()];
      yy -= dy[D.back()];
    }
    reverse(D.begin(), D.end());
    cerr << D.size() << '\n';
    int at = 0;
    while ((!outside(vx, vy, xlo, xhi, ylo, yhi) ||
            !outside(sx, sy, xlo, xhi, ylo, yhi)) &&
           (vx != sx || vy != sy)) {
      assert(at < int(D.size()));
      cerr << at << ' ' << D[at] << '\n';
      steps[step++] = stepcode[D[at]];
      cerr << vx << ' ' << vy << ' ' << sx << ' ' << sy << '\n';
      vx += dx[D[at]];
      vy += dy[D[at]];
      cerr << vx << ' ' << vy << ' ' << sx << ' ' << sy << '\n';
      assert(!tree(vx, vy));
      if (!tree(sx + dx[D[at]], sy + dy[D[at]])) {
        sx += dx[D[at]];
        sy += dy[D[at]];
        D.push_back(D[at]);
      }
      cerr << vx << ' ' << vy << ' ' << sx << ' ' << sy << '\n';
      cerr << '\n';
      ++at;
    }
  }
  if (vx != sx || vy != sy) {
    int d = -1;
    if ((vx > xhi || outside(vy, ylo, yhi)) &&
        (sx > xhi || outside(sy, ylo, yhi))) {
      d = 1;
    } else if ((vx < xlo || outside(vy, ylo, yhi)) &&
               (sx < xlo || outside(sy, ylo, yhi))) {
      d = 3;
    } else if ((vy > yhi || outside(vx, xlo, xhi)) &&
               (sy > yhi || outside(sx, xlo, xhi))) {
      d = 0;
    } else {
      assert((vy < ylo || outside(vx, xlo, xhi)) &&
             (vy < ylo || outside(sx, xlo, xhi)));
      d = 2;
    }
    vx += 500 * dx[d];
    vy += 500 * dy[d];
    sx += 500 * dx[d];
    sy += 500 * dy[d];
    for (int i = 0; i < 500; ++i) {
      steps[step++] = stepcode[d];
    }
    cerr << vx << ' ' << vy << ' ' << sx << ' ' << sy << '\n';
    if (d != 0) {
      if (d == 2) {
        for (int i = 0; i < 500; ++i) {
          steps[step++] = 'R';
        }
      }
      vy += 1000;
      sy += 1000;
      for (int i = 0; i < 1000; ++i) {
        steps[step++] = 'U';
      }
      cerr << vx << ' ' << vy << ' ' << sx << ' ' << sy << '\n';
      if (d == 2) {
        for (int i = 0; i < 500; ++i) {
          steps[step++] = 'L';
        }
      } else {
        d = (d + 2) % 4;
        cerr << "bla " << d << '\n';
        cerr << vx << ' ' << vy << ' ' << sx << ' ' << sy << '\n';
        vx += 500 * dx[d];
        vy += 500 * dy[d];
        sx += 500 * dx[d];
        sy += 500 * dy[d];
        for (int i = 0; i < 500; ++i) {
          steps[step++] = stepcode[d];
        }
        cerr << vx << ' ' << vy << ' ' << sx << ' ' << sy << '\n';
      }
    }
  }
  cerr << vx << ' ' << vy << ' ' << sx << ' ' << sy << '\n';
  if (vx != sx) {
    if (vx > sx) {
      vx += 500;
      sx += 500;
      for (int i = 0; i < 500; ++i) {
        steps[step++] = 'R';
      }
      int k = sy - y[n - 1];
      vy -= k;
      sy -= k;
      for (int i = 0; i < k; ++i) {
        steps[step++] = 'D';
      }
      while (vx != sx) {
        --vx;
        steps[step++] = 'L';
        if (sx - 1 > x[n - 1]) {
          --sx;
        }
      }
    } else {
      vx -= 500;
      sx -= 500;
      for (int i = 0; i < 500; ++i) {
        steps[step++] = 'L';
      }
      int k = sy - y[0];
      vy -= k;
      sy -= k;
      for (int i = 0; i < k; ++i) {
        steps[step++] = 'D';
      }
      while (vx != sx) {
        ++vx;
        steps[step++] = 'R';
        if (sx + 1 < x[0]) {
          ++sx;
        }
      }
    }
  }
  cerr << vx << ' ' << vy << ' ' << sx << ' ' << sy << '\n';
  assert(vx == sx);
  if (vy != sy) {
    if (vy > sy) {
      vy += 2000;
      sy += 2000;
      for (int i = 0; i < 2000; ++i) {
        steps[step++] = 'U';
      }
      int top = 0;
      for (int i = 1; i < n; ++i) {
        if (y[i] > y[top]) {
          top = i;
        }
      }
      if (vx > x[top]) {
        int k = vx - x[top];
        vx -= k;
        sx -= k;
        for (int i = 0; i < k; ++i) {
          steps[step++] = 'L';
        }
      } else {
        int k = -(vx - x[top]);
        vx += k;
        sx += k;
        for (int i = 0; i < k; ++i) {
          steps[step++] = 'R';
        }
      }
      while (vy != sy) {
        --vy;
        steps[step++] = 'D';
        if (sy - 1 > y[top]) {
          --sy;
        }
      }
    } else {
      vy -= 2000;
      sy -= 2000;
      for (int i = 0; i < 2000; ++i) {
        steps[step++] = 'D';
      }
      int bot = 0;
      for (int i = 1; i < n; ++i) {
        if (y[i] < y[bot]) {
          bot = i;
        }
      }
      if (vx > x[bot]) {
        int k = vx - x[bot];
        vx -= k;
        sx -= k;
        for (int i = 0; i < k; ++i) {
          steps[step++] = 'L';
        }
      } else {
        int k = -(vx - x[bot]);
        vx += k;
        sx += k;
        for (int i = 0; i < k; ++i) {
          steps[step++] = 'R';
        }
      }
      while (vy != sy) {
        ++vy;
        steps[step++] = 'U';
        if (sy + 1 < y[bot]) {
          ++sy;
        }
      }
    }
  }
  cerr << vx << ' ' << vy << ' ' << sx << ' ' << sy << '\n';
  int xx = orig_vx;
  int yy = orig_vy;
  for (int s = 0; s < step; ++s) {
    int d = stepcode.find(steps[s]);
    xx += dx[d];
    yy += dy[d];
  }
  cerr << xx << ' ' << yy << " expect " << vx << ' ' << vy;
  assert(xx == vx && yy == vy);
  xx = orig_sx;
  yy = orig_sy;
  for (int s = 0; s < step; ++s) {
    int d = stepcode.find(steps[s]);
    xx += dx[d];
    yy += dy[d];
    if (tree(xx, yy)) {
      xx -= dx[d];
      yy -= dy[d];
    }
  }
  cerr << xx << ' ' << yy << " expect " << sx << ' ' << sy;
  assert(xx == sx && yy == sy);
  puts(steps);
  return 0;
}