#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;
}
