#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline int checkBit(T n, T i) {
  return ((n >> i) & T(1));
}
inline int bitsCount(int v) {
  v = v - ((v >> 1) & 0x55555555);
  v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
  return ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
}
inline int bitsCount(long long v) {
  int t = v >> 32;
  int p = (v & ((1LL << 32) - 1));
  return bitsCount(t) + bitsCount(p);
}
unsigned int reverse_bits(register unsigned int x) {
  x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
  x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
  x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
  x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
  return ((x >> 16) | (x << 16));
}
template <typename T>
inline bool isPowerOfTwo(T n) {
  return (n != 0 and ((n & (n - 1)) == 0));
}
inline int binlog(int n) {
  assert(n > 0);
  return 32 - __builtin_clz(n) - 1;
}
inline int binlog(long long n) {
  assert(n > 0);
  return 64 - __builtin_clzll(n) - 1;
}
void bitprint(int n, int w = 32) {
  for (int i = w - 1; i >= 0; i--) {
    cout << checkBit(n, i);
  }
  cout << "\n";
}
void bitprint(long long n, int w = 64) {
  for (long long i = w - 1; i >= 0; i--) {
    cout << checkBit(n, i);
  }
  cout << "\n";
}
template <typename T>
inline T min(T a1, T a2, T a3) {
  return min(a1, min(a2, a3));
}
template <typename T>
inline T max(T a1, T a2, T a3) {
  return max(a1, max(a2, a3));
}
template <typename T>
inline T sqr(T x) {
  T x_ = (x);
  return x_ * x_;
}
template <typename T>
inline T qbr(T x) {
  T x_ = (x);
  return ((x_ * x_) * x_);
}
template <typename T>
inline int sign(T x) {
  T x_ = (x);
  return ((x_ > T(0)) - (x_ < T(0)));
}
template <typename T>
inline T mod(T x, T m) {
  T x_ = (x);
  return (((x_) >= 0) ? ((x_) % (m)) : ((((x_) % (m)) + (m)) % (m)));
}
template <typename T>
inline T gcd(T a, T b) {
  while (b) {
    T t = a % b;
    a = b;
    b = t;
  }
  return a;
}
template <typename T>
inline T gcd_ex(T a, T b, T& x, T& y) {
  if (b == 0) {
    x = 1, y = 0;
    return a;
  }
  T x1, y1;
  T d = gcd_ex(b, a % b, x1, y1);
  x = y1;
  y = x1 - (a / b) * y1;
  return d;
}
template <typename T>
inline T lcm(T a, T b) {
  return (a * (b / gcd(a, b)));
}
template <typename A, typename B, typename C>
function<C(A)> combine(function<B(A)> f, function<C(B)> g) {
  return bind(g, bind(f, placeholders::_1));
}
template <typename Collection, typename UnaryOperation>
void foreach (Collection& col, UnaryOperation op) {
  for_each(begin(col), end(col), op);
}
template <typename Collection, typename UnaryOperation>
Collection fmap(Collection& col, UnaryOperation op) {
  transform(begin(col), end(col), col.begin(), op);
  return col;
}
template <typename Collection, typename binop>
Collection zip(Collection& fc, Collection& sc, binop op) {
  transform(begin(fc), end(fc), sc.begin(), fc.begin(), op);
  return fc;
}
template <typename Collection, typename Condition>
bool exists(Collection& col, Condition con) {
  auto exist = find_if(begin(col), end(col), con);
  return exist != col.end();
}
template <typename Collection, typename Predicate>
Collection filterNot(Collection& col, Predicate predicate) {
  auto returnIterator = remove_if(begin(col), end(col), predicate);
  col.erase(returnIterator, end(col));
  return col;
}
void fastIO() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
}
template <class T1, class T2>
istream& operator>>(istream& in, pair<T1, T2>& P) {
  in >> P.first >> P.second;
  return in;
}
template <class T>
istream& operator>>(istream& in, vector<T>& Col) {
  for (auto& el : Col) in >> el;
  return in;
}
template <class T>
inline void getarr(T* arr, int l, int r) {
  for (long long i = l; i < r; i++) cin >> arr[i];
}
template <class T1, class T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
  os << "(" << p.first << ", " << p.second << ")";
  return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<vector<T>>& v) {
  for (auto& row : v) {
    for (auto& el : row) os << el << " ";
    os << "\n";
  }
  return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& Col) {
  os << "[";
  for (size_t i = 0; i < Col.size(); ++i) {
    os << Col[i];
    if (i != Col.size() - 1) {
      os << " ";
    }
  }
  os << "]";
  return os;
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& Col) {
  for (auto& el : Col) os << el << " ";
  return os;
}
template <class T1, class T2>
ostream& operator<<(ostream& os, const map<T1, T2>& Col) {
  for (auto& el : Col) os << el << " ";
  return os;
}
string f(int n) {
  string res;
  if (n == 0) {
    res.push_back('0');
  }
  while (n) {
    res.push_back(n % 10 + '0');
    n /= 10;
  }
  reverse(begin(res), end(res));
  return res;
}
int main() {
  fastIO();
  int n, m, s, d;
  cin >> n >> m >> s >> d;
  int rightmax = 0;
  vector<int> a(n);
  cin >> a;
  sort(begin(a), end(a));
  vector<pair<int, int>> b;
  b.push_back({0, a[0] - 1});
  for (int i = 1; i < n; i++) {
    if (a[i - 1] + 1 <= a[i] - 1) {
      b.push_back({a[i - 1] + 1, a[i] - 1});
    }
  }
  b.push_back({a[n - 1] + 1, m});
  vector<int> p(b.size());
  int lastid = 0;
  for (int i = 0; i < b.size(); i++) {
    if (b[i].first <= rightmax) {
      p[i] = lastid;
      if (b[i].second - b[i].first >= s) {
        rightmax = b[i].second + d;
        lastid = i;
      }
    }
  }
  if (rightmax < m) {
    cout << "IMPOSSIBLE\n";
    return 0;
  }
  vector<string> ans;
  int temp = p.size() - 1;
  while (temp != p[temp]) {
    ans.push_back("RUN " + f(b[temp].second - b[temp].first));
    ans.push_back("JUMP " + f(b[temp].first - b[p[temp]].second));
    temp = p[temp];
  }
  ans.push_back("RUN " + f(b[temp].second - b[temp].first));
  reverse(begin(ans), end(ans));
  for (int i = 0; i < ans.size(); i++) {
    if (ans[i] != "RUN 0") {
      cout << ans[i] << '\n';
    }
  }
  return 0;
}
