#include <bits/stdc++.h>
using namespace std;
long long n, t, a, b, c;
pair<int, int> z1, z2, z3, z4;
inline long long ac(long long a, long long b) {
  return (a + b) * (b - a + 1) / 2;
}
long long val(pair<int, int> cur, pair<int, int> p1, pair<int, int> p2) {
  long long l, r, cc, t1, n;
  if (p1.second == p2.second)
    l = p1.first, r = p2.first, n = r - l + 1,
    t1 = n * abs(cur.second - p1.second), cc = cur.first;
  else
    l = p1.second, r = p2.second, n = r - l + 1,
    t1 = n * abs(cur.first - p1.first), cc = cur.second;
  if (n <= 0) return 0;
  if (cc > r)
    return ac(cc - r, cc - l) + t1;
  else if (cc < l)
    return ac(l - cc, r - cc) + t1;
  else
    return ac(0, cc - l) + ac(0, r - cc) + t1;
}
struct inter {
  pair<int, int> left, right;
  inter(pair<int, int> a = {0, 0}, pair<int, int> b = {0, 0})
      : left(a), right(b) {}
};
long long eval(pair<int, int> pos, vector<inter> &h) {
  long long ret = 0;
  for (int i = 0; i < h.size(); i++) {
    ret += val(pos, h[i].left, h[i].right);
  }
  return ret;
}
inline long long dist(pair<int, int> a, pair<int, int> b) {
  return abs(a.first - b.first) + abs(a.second - b.second);
}
inline long long ceil2(long long a) {
  if (a % 2 == 0)
    return a / 2;
  else if (a > 0)
    return a / 2 + 1;
  else
    return a / 2;
}
inline long long floor2(long long a) {
  if (a >= 0)
    return a / 2;
  else if (a % 2 == 0)
    return a / 2;
  else
    return a / 2 - 1;
}
bool stok(pair<int, int> pos, long long t1, long long t2, long long t3,
          long long t4) {
  vector<inter> test, test2;
  if (pos.second > b + c - 1) {
    test.push_back({{pos.first + 1, pos.second}, {n, pos.second}});
    test.push_back({{n, pos.second + 1}, {n, n}});
    t1 -= eval(z1, test), t2 -= eval(z2, test), t3 -= eval(z3, test),
        t4 -= eval(z4, test);
    if (t1 < 0 || t2 < 0 || t3 < 0 || t4 < 0)
      return 0;
    else
      return 1;
  } else if (pos.first > a + c - 1) {
    test.push_back({{pos.first, pos.second + 1}, {pos.first, n}});
    test.push_back({{pos.first + 1, n}, {n, n}});
    t1 -= eval(z1, test), t2 -= eval(z2, test), t3 -= eval(z3, test),
        t4 -= eval(z4, test);
    if (t1 < 0 || t2 < 0 || t3 < 0 || t4 < 0)
      return 0;
    else
      return 1;
  } else if (pos.first >= a && pos.second >= b) {
    test.push_back({{pos.first + 1, pos.second}, {a + c - 1, pos.second}});
    test.push_back({{a + c - 1, pos.second + 1}, {a + c - 1, n}});
    test.push_back({{a + c, n}, {n, n}});
    test2.push_back({{pos.first, pos.second + 1}, {pos.first, b + c - 1}});
    test2.push_back({{pos.first + 1, b + c - 1}, {n, b + c - 1}});
    test2.push_back({{n, b + c}, {n, n}});
  } else if (pos.first >= a) {
    test.push_back({{pos.first, pos.second + 1}, {pos.first, b}});
    test.push_back({{pos.first + 1, b}, {a + c - 1, b}});
    test.push_back({{a + c - 1, b + 1}, {a + c - 1, n}});
    test.push_back({{a + c, n}, {n, n}});
    test2.push_back({{pos.first, pos.second + 1}, {pos.first, b + c - 1}});
    test2.push_back({{pos.first + 1, b + c - 1}, {n, b + c - 1}});
    test2.push_back({{n, b + c}, {n, n}});
  } else if (pos.second >= b) {
    test.push_back({{pos.first + 1, pos.second}, {a + c - 1, pos.second}});
    test.push_back({{a + c - 1, pos.second + 1}, {a + c - 1, n}});
    test.push_back({{a + c, n}, {n, n}});
    test2.push_back({{pos.first + 1, pos.second}, {a, pos.second}});
    test2.push_back({{a, pos.second + 1}, {a, b + c - 1}});
    test2.push_back({{a + 1, b + c - 1}, {n, b + c - 1}});
    test2.push_back({{n, b + c}, {n, n}});
  } else {
    test.push_back({{pos.first, pos.second + 1}, {pos.first, b}});
    test.push_back({{pos.first + 1, b}, {a + c - 1, b}});
    test.push_back({{a + c - 1, b + 1}, {a + c - 1, n}});
    test.push_back({{a + c, n}, {n, n}});
    test2.push_back({{pos.first + 1, pos.second}, {a, pos.second}});
    test2.push_back({{a, pos.second + 1}, {a, b + c - 1}});
    test2.push_back({{a + 1, b + c - 1}, {n, b + c - 1}});
    test2.push_back({{n, b + c}, {n, n}});
  }
  t1 -= eval(z1, test), t2 -= eval(z2, test);
  long long t3l = t3 - eval(z3, test), t3u = t3 - eval(z3, test2);
  long long t4l = t4 - eval(z4, test), t4u = t4 - eval(z4, test2);
  if (t1 < 0 || t2 < 0)
    return 0;
  else {
    if (t3l > t3u) swap(t3l, t3u), swap(t4l, t4u);
    long long kl = max(ceil2(-t3l), (long long)0),
              ku = min(floor2(t4l), floor2(t3u - t3l));
    if (kl > ku)
      return 0;
    else
      return 1;
  }
}
void printOpt(pair<int, int> pos, long long t1, long long t2, long long t3,
              long long t4) {
  if (pos.first == n && pos.second == n) return;
  if (pos.first == n) {
    printf("U");
    pair<int, int> next = {pos.first, pos.second + 1};
    printOpt(next, t1 - dist(next, z1), t2 - dist(next, z2),
             t3 - dist(next, z3), t4 - dist(next, z4));
  } else if (pos.second == n) {
    printf("R");
    pair<int, int> next = {pos.first + 1, pos.second};
    printOpt(next, t1 - dist(next, z1), t2 - dist(next, z2),
             t3 - dist(next, z3), t4 - dist(next, z4));
  } else {
    pair<int, int> selR = {pos.first + 1, pos.second};
    bool ok = stok(selR, t1 - dist(selR, z1), t2 - dist(selR, z2),
                   t3 - dist(selR, z3), t4 - dist(selR, z4));
    if (ok) {
      printf("R");
      printOpt(selR, t1 - dist(selR, z1), t2 - dist(selR, z2),
               t3 - dist(selR, z3), t4 - dist(selR, z4));
    } else {
      printf("U");
      selR = {pos.first, pos.second + 1};
      printOpt(selR, t1 - dist(selR, z1), t2 - dist(selR, z2),
               t3 - dist(selR, z3), t4 - dist(selR, z4));
    }
  }
}
int main() {
  scanf("%lld%lld%lld%lld%lld", &n, &t, &a, &b, &c);
  pair<int, int> cur = {1, 1};
  z1 = {a, b}, z2 = {a + c - 1, b + c - 1}, z3 = {a + c - 1, b},
  z4 = {a, b + c - 1};
  if (!stok(cur, t, t, t, t))
    printf("Impossible\n");
  else {
    printOpt(cur, t, t, t, t);
  }
  return 0;
}
