#include<bits/stdc++.h>
using namespace std;

const int N = 2e5 + 6;
int n, m, s, d;
int a[N];
vector< pair<int, int> > segs;
vector<string> ans;

int main()
{
	cin >> n >> m >> s >> d;
	for(int i = 1; i <= n; i++)
	{
		cin >> a[i];
	}

	sort(a + 1, a + 1 + n);
	a[0] = 0;
	a[n + 1] = m;
	int curPos = 0;

	for(int i = 1; i <= n + 1; i++)
	{
		int rightFree = a[i] - 1;
		int leftFree = a[i - 1] + 1;
		if(rightFree < leftFree)continue;
		if((i != n + 1) and rightFree - leftFree < s)continue;
		if(i != 1 and i != (n + 1))
		segs.push_back(make_pair(leftFree, rightFree));
		else if(i == 1)
		{
			segs.push_back(make_pair(0, rightFree));
		}
		else if(i == n + 1)
		{
			segs.push_back(make_pair(leftFree, m));
		}
	}

	for(int i = 1; i < segs.size(); i++)
	{
		if(segs[i].first - segs[i - 1].second > d)
		{
			cout << "IMPOSSIBLE";
			return 0;
		}
	}

	for(int i = 0; i < segs.size(); i++)
	{
		//cout << segs[i].first << " " << segs[i].second << endl;
	}

	for(int i = 0; i < segs.size(); i++)
	{
		if(i != (segs.size() - 1))
		{
			cout << "RUN ";
			cout << segs[i].second - segs[i].first << endl;
			cout << "JUMP ";
			cout << segs[i + 1].first - segs[i].second << endl;
		}
		else
		{
			cout << "RUN ";
			cout << segs[i].second - segs[i].first << endl;
		}
	}
}


#include<bits/stdc++.h>
using namespace std;

const int N = 2e5 + 6;
int n, m, s, d;
int a[N];
vector< pair<int, int> > segs;
vector<string> ans;

int main()
{
	cin >> n >> m >> s >> d;
	for(int i = 1; i <= n; i++)
	{
		cin >> a[i];
	}

	sort(a + 1, a + 1 + n);
	a[0] = 0;
	a[n + 1] = m;
	int curPos = 0;

	for(int i = 1; i <= n + 1; i++)
	{
		int rightFree = a[i] - 1;
		int leftFree = a[i - 1] + 1;
		if(rightFree < leftFree)continue;
		if((i != n + 1) and rightFree - leftFree + 1 < s)continue;
		if(i != 1 and i != (n + 1))
		segs.push_back(make_pair(leftFree, rightFree));
		else if(i == 1)
		{
			segs.push_back(make_pair(0, rightFree));
		}
		else if(i == n + 1)
		{
			segs.push_back(make_pair(leftFree, m));
		}
	}

	for(int i = 1; i < segs.size(); i++)
	{
		if(segs[i].first - segs[i - 1].second > d)
		{
			cout << "IMPOSSIBLE";
			return 0;
		}
	}

	for(int i = 0; i < segs.size(); i++)
	{
		//cout << segs[i].first << " " << segs[i].second << endl;
	}

	for(int i = 0; i < segs.size(); i++)
	{
		if(i != (segs.size() - 1))
		{
			cout << "RUN ";
			cout << segs[i].second - segs[i].first << endl;
			cout << "JUMP ";
			cout << segs[i + 1].first - segs[i].second << endl;
		}
		else
		{
			cout << "RUN ";
			cout << segs[i].second - segs[i].first << endl;
		}
	}
}


#include<bits/stdc++.h>
using namespace std;

const int N = 2e5 + 6;
int n, m, s, d;
int a[N];
vector< pair<int, int> > segs;
vector<string> ans;

int main()
{
	cin >> n >> m >> s >> d;
	for(int i = 1; i <= n; i++)
	{
		cin >> a[i];
	}

	sort(a + 1, a + 1 + n);
	a[0] = 0;
	a[n + 1] = m;
	int curPos = 0;

	for(int i = 1; i <= n + 1; i++)
	{
		int rightFree = a[i] - 1;
		int leftFree = a[i - 1] + 1;
		if(rightFree < leftFree)continue;
		if((i != 1 and i != n + 1) and rightFree - leftFree + 1 < s)continue;
		if(i != 1 and i != (n + 1))
		segs.push_back(make_pair(leftFree, rightFree));
		else if(i == 1)
		{
			segs.push_back(make_pair(0, rightFree));
		}
		else if(i == n + 1)
		{
			segs.push_back(make_pair(leftFree, m));
		}
	}

	for(int i = 1; i < segs.size(); i++)
	{
		if(segs[i].first - segs[i - 1].second > d)
		{
			cout << "IMPOSSIBLE";
			return 0;
		}
	}

	for(int i = 0; i < segs.size(); i++)
	{
		//cout << segs[i].first << " " << segs[i].second << endl;
	}

	for(int i = 0; i < segs.size(); i++)
	{
		if(i != (segs.size() - 1))
		{
			cout << "RUN ";
			cout << segs[i].second - segs[i].first << endl;
			cout << "JUMP ";
			cout << segs[i + 1].first - segs[i].second << endl;
		}
		else
		{
			cout << "RUN ";
			cout << segs[i].second - segs[i].first << endl;
		}
	}
}


#include <stdio.h>
#include <vector>
#include <iostream>
#include <algorithm>

using namespace std;

int const maxn = 200001;
int a[maxn];
int id[maxn];

int main(){
    int n, m, s, d;
    scanf("%d %d %d %d", &n, &m, &s, &d);
    for (int i = 1; i <= n; i ++)
        scanf("%d", &a[i]);
    sort(a + 1, a + n + 1);
    int sz = 0;
    a[0] = -1;
    a[n + 1] = m + 1;
    for (int i = 1; i <= n + 1; i ++)
        if(a[i] - a[i - 1] - 1 > s)id[sz ++] = i;
   /* cerr << "idd --> " << endl;
    for (int i = 0; i < sz; i ++)
        cerr << id[i] << ' ';
    cerr << endl;*/
    if(id[0] == 0)
        return puts("IMPOSSIBLE"), 0;
    if(a[n] + 1 - a[id[sz - 1]] + 1 > d)
        return puts("IMPOSSIBLE"), 0;
    for (int i = 1; i < sz; i ++)
        if(a[id[i] - 1] + 1 - a[id[i - 1]] + 1 > d)
            return puts("IMPOSSIBLE"), 0;
    int cur = 0;
    for (int i = 1; i < sz; i ++){
        int val = a[id[i - 1]] - 1 - cur;
        cur = a[id[i - 1]] - 1;
        int t = a[id[i] - 1] + 1;
        t = t - cur;
        printf("%s %d\n", "RUN", val);
        printf("%s %d\n", "JUMP", t);
        cur = a[id[i] - 1] + 1;
    }
    if(cur != m){
        printf("%s %d\n", "RUN", m - cur);
    }
    return 0;
}


#include <stdio.h>
#include <vector>
#include <iostream>
#include <algorithm>

using namespace std;

int const maxn = 200001;
int a[maxn];
int id[maxn];

int main(){
    int n, m, s, d;
    scanf("%d %d %d %d", &n, &m, &s, &d);
    for (int i = 1; i <= n; i ++)
        scanf("%d", &a[i]);
    sort(a + 1, a + n + 1);
    int sz = 0;
    a[0] = -1;
    a[n + 1] = m + 1;
    for (int i = 1; i <= n + 1; i ++)
        if(a[i] - a[i - 1] - 1 > s)id[sz ++] = i;
   /* cerr << "idd --> " << endl;
    for (int i = 0; i < sz; i ++)
        cerr << id[i] << ' ';
    cerr << endl;*/
    if(id[0] == 0)
        return puts("IMPOSSIBLE"), 0;
    //if(a[n] + 1 - a[id[sz - 1]] + 1 > d)
      //  return puts("IMPOSSIBLE"), 0;
    for (int i = 1; i < sz; i ++)
        if(a[id[i] - 1] + 1 - a[id[i - 1]] + 1 > d)
            return puts("IMPOSSIBLE"), 0;
    int cur = 0;
    if(id[sz - 1] != n + 1)id[sz ++] = n + 1;
    for (int i = 1; i < sz; i ++){
        int val = a[id[i - 1]] - 1 - cur;
        cur = a[id[i - 1]] - 1;
        int t = a[id[i] - 1] + 1;
        t = t - cur;
        printf("%s %d\n", "RUN", val);
        printf("%s %d\n", "JUMP", t);
        cur = a[id[i] - 1] + 1;
    }
    if(cur != m){
        printf("%s %d\n", "RUN", m - cur);
    }
    return 0;
}


#include <stdio.h>
#include <vector>
#include <iostream>
#include <algorithm>

using namespace std;

int const maxn = 200001;
int a[maxn];
int id[maxn];

int main(){
    int n, m, s, d;
    scanf("%d %d %d %d", &n, &m, &s, &d);
    for (int i = 1; i <= n; i ++)
        scanf("%d", &a[i]);
    sort(a + 1, a + n + 1);
    int sz = 0;
    a[0] = -1;
    a[n + 1] = m + 1;
    for (int i = 1; i <= n + 1; i ++)
        if(a[i] - a[i - 1] - 1 > s)id[sz ++] = i;
   /*cerr << "idd --> " << endl;
    for (int i = 0; i < sz; i ++)
        cerr << id[i] << ' ';
    cerr << endl;*/
    if(id[0] != 1)
        return puts("IMPOSSIBLE"), 0;
    if(a[n] + 1 - a[id[sz - 1]] + 1 > d)
        return puts("IMPOSSIBLE"), 0;
    for (int i = 1; i < sz; i ++)
        if(a[id[i] - 1] + 1 - a[id[i - 1]] + 1 > d)
            return puts("IMPOSSIBLE"), 0;
    int cur = 0;
    if(id[sz - 1] != n + 1)id[sz ++] = n + 1;
    for (int i = 1; i < sz; i ++){
        int val = a[id[i - 1]] - 1 - cur;
        cur = a[id[i - 1]] - 1;
        int t = a[id[i] - 1] + 1;
        t = t - cur;
        printf("%s %d\n", "RUN", val);
        printf("%s %d\n", "JUMP", t);
        cur = a[id[i] - 1] + 1;
    }
    if(cur != m){
        printf("%s %d\n", "RUN", m - cur);
    }
    return 0;
}


#include <stdio.h>
#include <vector>
#include <iostream>
#include <algorithm>

using namespace std;

int const maxn = 200001;
int a[maxn];
int id[maxn];

int main(){
    int n, m, s, d;
    scanf("%d %d %d %d", &n, &m, &s, &d);
    for (int i = 1; i <= n; i ++)
        scanf("%d", &a[i]);
    sort(a + 1, a + n + 1);
    int sz = 0;
    a[0] = -1;
    a[n + 1] = m + 1;
    for (int i = 1; i <= n + 1; i ++)
        if(a[i] - a[i - 1] - 1 > s)id[sz ++] = i;
   /* cerr << "idd --> " << endl;
    for (int i = 0; i < sz; i ++)
        cerr << id[i] << ' ';
    cerr << endl;*/
    if(id[0] == 0)
        return puts("IMPOSSIBLE"), 0;
    if(a[n] + 1 - a[id[sz - 1]] + 1 > d)
        return puts("IMPOSSIBLE"), 0;
    for (int i = 1; i < sz; i ++)
        if(a[id[i] - 1] + 1 - a[id[i - 1]] + 1 > d)
            return puts("IMPOSSIBLE"), 0;
    int cur = 0;
    if(id[sz - 1] != n + 1)id[sz ++] = n + 1;
    for (int i = 1; i < sz; i ++){
        int val = a[id[i - 1]] - 1 - cur;
        cur = a[id[i - 1]] - 1;
        int t = a[id[i] - 1] + 1;
        t = t - cur;
        printf("%s %d\n", "RUN", val);
        printf("%s %d\n", "JUMP", t);
        cur = a[id[i] - 1] + 1;
    }
    if(cur != m){
        printf("%s %d\n", "RUN", m - cur);
    }
    return 0;
}


#include <stdio.h>
#include <vector>
#include <iostream>
#include <algorithm>

using namespace std;

int const maxn = 200001;
int a[maxn];
int id[maxn];

int main(){
    int n, m, s, d;
    scanf("%d %d %d %d", &n, &m, &s, &d);
    for (int i = 1; i <= n; i ++)
        scanf("%d", &a[i]);
    sort(a + 1, a + n + 1);
    int sz = 0;
    a[0] = -1;
    a[n + 1] = m + 1;
    for (int i = 1; i <= n + 1; i ++)
        if(a[i] - a[i - 1] - 1 > s)id[sz ++] = i;
   /*cerr << "idd --> " << endl;
    for (int i = 0; i < sz; i ++)
        cerr << id[i] << ' ';
    cerr << endl;*/
    if(id[0] != 1)
        return puts("IMPOSSIBLE"), 0;
    /*if(a[n] + 1 - a[id[sz - 1]] + 1 > d)
        return puts("IMPOSSIBLE"), 0;*/
    for (int i = 1; i < sz; i ++)
        if(a[id[i] - 1] + 1 - a[id[i - 1]] + 1 > d)
            return puts("IMPOSSIBLE"), 0;
    int cur = 0;
    if(id[sz - 1] != n + 1)id[sz ++] = n + 1;
    for (int i = 1; i < sz; i ++){
        int val = a[id[i - 1]] - 1 - cur;
        cur = a[id[i - 1]] - 1;
        int t = a[id[i] - 1] + 1;
        t = t - cur;
        printf("%s %d\n", "RUN", val);
        printf("%s %d\n", "JUMP", t);
        cur = a[id[i] - 1] + 1;
    }
    if(cur != m){
        printf("%s %d\n", "RUN", m - cur);
    }
    return 0;
}


#include<iostream>
#include<algorithm>
#include<set>
#include<vector>
#include<list>
#include<string>
using namespace std;

int main()
{
    std::ios::sync_with_stdio(false);
	int n, m, s, d;
	cin >> n >> m >> s >> d;
	if (d == 1)
	{
		cout << "IMPOSSIBLE";
		return 0;
	}

	vector<int> barriers(n);
	for (int i = 0; i < n; i++)
	{
		int pos;
		cin >> pos;
		barriers[i] = pos;
	}

	sort(barriers.begin(), barriers.end());

	int last_pos = -1;

	list<string> ans;

	for (int i = 0; i < barriers.size(); i++)
	{
		int available_distance = barriers[i] - last_pos - 2;

		if (available_distance < s)
		{
			cout << "IMPOSSIBLE";
			return 0;
		}

		ans.push_back("RUN " + to_string(available_distance));

		int j = i;

		for (j++; j < barriers.size(); j++)
		{
			if (barriers[j] + 2 - barriers[i] > d)
			{
				break;
			}

			if (barriers[j] - barriers[j - 1] - 2 >= s)
			{
				break;
			}
		}

		ans.push_back("JUMP " + to_string(barriers[--j] - barriers[i] + 2));
		i = j;
		last_pos = barriers[i];
	}

	if (last_pos + 1 != m)
	{
		ans.push_back("RUN " + to_string(m - *(--barriers.end()) - 1));
	}

	for (auto i = ans.begin(); i != ans.end(); i++)
	{
		cout << *i << "\n";
	}
	return 0;
}


#include<iostream>
#include<algorithm>
#include<set>
#include<vector>
#include<list>
#include<string>
using namespace std;

int main()
{
	int n, m, s, d;
	cin >> n >> m >> s >> d;
	if (d == 1)
	{
		cout << "IMPOSSIBLE";
		return 0;
	}

	vector<int> barriers(n);
	for (int i = 0; i < n; i++)
	{
		int pos;
		cin >> pos;
		barriers[i] = pos;
	}

	sort(barriers.begin(), barriers.end());

	int last_pos = -1;

	list<string> ans;

	for (int i = 0; i < barriers.size(); i++)
	{
		int available_distance = barriers[i] - last_pos - 2;

		if (available_distance < s)
		{
			cout << "IMPOSSIBLE";
			return 0;
		}

		ans.push_back("RUN " + to_string(available_distance));

		int j = i;

		for (j++; j < barriers.size(); j++)
		{
			if (barriers[j] + 2 - barriers[i] > d)
			{
				break;
			}

			if (barriers[j] - barriers[j - 1] - 2 >= s)
			{
				break;
			}
		}

		ans.push_back("JUMP " + to_string(barriers[--j] - barriers[i] + 2));
		i = j;
		last_pos = barriers[i];
	}

	if (last_pos + 1 != m)
	{
		ans.push_back("RUN " + to_string(m - *(--barriers.end()) - 1));
	}

	for (auto i = ans.begin(); i != ans.end(); i++)
	{
		cout << *i << "\n";
	}
	return 0;
}


#include<iostream>
#include<algorithm>
#include<set>
#include<vector>
#include<list>
#include<string>
using namespace std;

int main()
{
	int n, m, s, d;
	cin >> n >> m >> s >> d;
	if (d == 1)
	{
		cout << "IMPOSSIBLE";
		return 0;
	}

	vector<int> barriers(n);
	for (int i = 0; i < n; i++)
	{
		int pos;
		scanf("%d", &pos);
		barriers[i] = pos;
	}

	sort(barriers.begin(), barriers.end());

	int last_pos = -1;

	list<string> ans;

	for (int i = 0; i < barriers.size(); i++)
	{
		int available_distance = barriers[i] - last_pos - 2;

		if (available_distance < s)
		{
			cout << "IMPOSSIBLE";
			return 0;
		}

		ans.push_back("RUN " + to_string(available_distance));

		int j = i;

		for (j++; j < barriers.size(); j++)
		{
			if (barriers[j] + 2 - barriers[i] > d)
			{
				break;
			}

			if (barriers[j] - barriers[j - 1] - 2 >= s)
			{
				break;
			}
		}

		ans.push_back("JUMP " + to_string(barriers[--j] - barriers[i] + 2));
		i = j;
		last_pos = barriers[i];
	}

	if (last_pos + 1 != m)
	{
		ans.push_back("RUN " + to_string(m - *(--barriers.end()) - 1));
	}

	for (auto i = ans.begin(); i != ans.end(); i++)
	{
		cout << *i << "\n";
	}
	return 0;
}


#include<iostream>
#include<algorithm>
#include<set>
#include<vector>
#include<list>
#include<string>
using namespace std;

int main()
{
	int n, m, s, d;
	cin >> n >> m >> s >> d;
	if (d == 1)
	{
		cout << "IMPOSSIBLE";
		return 0;
	}

	vector<int> barriers(n);
	for (int i = 0; i < n; i++)
	{
		int pos;
		scanf("%d", &pos);
		barriers[i] = pos;
	}

	sort(barriers.begin(), barriers.end());

	int last_pos = -1;

	list<string> ans;

	for (int i = 0; i < barriers.size(); i++)
	{
		int available_distance = barriers[i] - last_pos - 2;

		if (available_distance < s)
		{
			cout << "IMPOSSIBLE";
			return 0;
		}

		ans.push_back("RUN " + to_string(available_distance));

		int j = i;

		for (j++; j < barriers.size(); j++)
		{
			if (barriers[j] + 2 - barriers[i] > d)
			{
				break;
			}

			if (barriers[j] - barriers[j - 1] - 2 >= s)
			{
				break;
			}
		}

		ans.push_back("JUMP " + to_string(barriers[--j] - barriers[i] + 2));
		i = j;
		last_pos = barriers[i];
	}

	if (last_pos + 1 != m)
	{
		ans.push_back("RUN " + to_string(m - *(--barriers.end()) - 1));
	}

	for (auto i = ans.begin(); i != ans.end(); i++)
	{
		printf((*i).c_str());
		printf("\n");
	}
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
int n,m,s,d;
int a[200005];
int cnt;
struct node{
	int l,r;
}e[200005];
int main(){
	scanf("%d%d%d%d",&n,&m,&s,&d);
	for(int i=1;i<=n;i++){
		scanf("%d",&a[i]);
	}
	sort(a+1,a+1+n);
	for(int i=1;i<=n;i++){
		if(a[i]==a[i-1]) continue;
		if(a[i]-a[i-1]-1>s) e[++cnt].l=a[i],e[cnt].r=a[i];
		else e[cnt].r=a[i];
	}
	for(int i=1;i<=cnt;i++)
		if(e[i].r-e[i].l+1>=d){
			printf("IMPOSSIBLE\n");
			return 0;
		}
	int now=0;
	for(int i=1;i<=cnt;i++){
		if(e[i].l!=1){
			printf("RUN %d\n",e[i].l-1-now);
			printf("JUMP %d\n",e[i].r+1-(e[i].l-1));
			now=e[i].r+1;
		}
	}
	if(now<m)  printf("RUN %d\n",m-now);
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
int n,m,s,d;
int a[200005];
int cnt;
struct node{
	int l,r;
}e[200005];
int main(){
	scanf("%d%d%d%d",&n,&m,&s,&d);
	for(int i=1;i<=n;i++){
		scanf("%d",&a[i]);
	}
	sort(a+1,a+1+n);
	for(int i=1;i<=n;i++){
		if(a[i]-a[i-1]-1>s) e[++cnt].l=a[i],e[cnt].r=a[i];
		else e[cnt].r=a[i];
	}
	for(int i=1;i<=cnt;i++)
		if(e[i].r-e[i].l+1>=d){
			printf("IMPOSSIBLE\n");
			return 0;
		}
	int now=0;
	for(int i=1;i<=cnt;i++){
		if(e[i].l!=1){
			printf("RUN %d\n",e[i].l-1-now);
			printf("JUMP %d\n",e[i].r+1-(e[i].l-1));
			now=e[i].r+1;
		}
	}
	if(now<m)  printf("RUN %d\n",m-now);
	return 0;
}


#include<bits/stdc++.h>
#define int long long
using namespace std;
int n,m,s,d;
int a[200005];
int cnt;
struct node{
	int l,r;
}e[200005];
signed main(){
	scanf("%lld%lld%lld%lld",&n,&m,&s,&d);
	for(int i=1;i<=n;i++){
		scanf("%lld",&a[i]);
	}
	sort(a+1,a+1+n);
	if(a[1]-1<s){
		printf("IMPOSSIBLE\n");
		return 0;
	}
	for(int i=1;i<=n;i++){
		if(a[i]-a[i-1]-1>s) e[++cnt].l=a[i],e[cnt].r=a[i];
		else e[cnt].r=a[i];
	}
	for(int i=1;i<=cnt;i++)
		if(e[i].r-e[i].l+1>=d){
			printf("IMPOSSIBLE\n");
			return 0;
		}
	int now=0;
	for(int i=1;i<=cnt;i++){
		if(e[i].l!=1){
			printf("RUN %lld\n",e[i].l-1-now);
			printf("JUMP %lld\n",e[i].r+1-(e[i].l-1));
			now=e[i].r+1;
		}
	}
	if(now<m)  printf("RUN %lld\n",m-now);
	return 0;
}


#include<bits/stdc++.h>
#define int long long
using namespace std;
int n,m,s,d;
int a[200005];
int cnt;
struct node{
	int l,r;
}e[200005];
signed main(){
	scanf("%lld%lld%lld%lld",&n,&m,&s,&d);
	for(int i=1;i<=n;i++){
		scanf("%lld",&a[i]);
	}
	sort(a+1,a+1+n);
	if(a[1]-1<s){
		printf("IMPOSSIBLE\n");
		return 0;
	}
	a[0]=-(1e9+7);
	for(int i=1;i<=n;i++){
		if(a[i]-a[i-1]-1>s) e[++cnt].l=a[i],e[cnt].r=a[i];
		else e[cnt].r=a[i];
	}
	for(int i=1;i<=cnt;i++)
		if(e[i].r-e[i].l+1>=d){
			printf("IMPOSSIBLE\n");
			return 0;
		}
	int now=0;
	for(int i=1;i<=cnt;i++){
		if(e[i].l!=1){
			printf("RUN %lld\n",e[i].l-1-now);
			printf("JUMP %lld\n",e[i].r+1-(e[i].l-1));
			now=e[i].r+1;
		}
	}
	if(now<m)  printf("RUN %lld\n",m-now);
	return 0;
}


#include<bits/stdc++.h>
#define debug(x) cout<<#x<<"  : "<<x<<endl;
#define foreach(it,v) for(__typeof(v.begin()) it = v.begin(); it != v.end(); ++it)
#define pii pair<int ,int>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 10;
const int M = 128;
const int inf = 0x7fffffff;
const ll INF = 9E18;
const int mod = 1e9 + 7;
const int eps = 1e-7;

ll a[maxn];
vector<ll> ans;

int main()
{
    ll n , m , s , d;
    cin>>n>>m>>s>>d;
    for(int i = 0 ; i < n ; i++ )
        cin>>a[i];
    sort( a , a + n );
    a[n] = m + 1;
    ll now  = a[0] - 1 , last = 0 , flag = 0;
    ans.push_back( now - last );
    for(int i = 0 ; i < n ; i++ ){
        if( now - last < s ){
            flag = 1;
            break;
        }
        int can = 0 , j;
        for(j = i + 1 ; j <= n ; j++ ){
            if( a[j] + 1 - now > d  )
                break;
            if( a[j] - a[j - 1] - 2 >= s || j == n ){
                can = 1;
                break;
            }
            i++;
        }
        last = a[j - 1] + 1;
        ans.push_back( last - now );
        now = a[j] - 1;
        //debug(now)
        ans.push_back( now - last );
    }
    if( flag ){
        puts("IMPOSSIBLE");
        return 0;
    }
    for(int i = 0 ; i < ans.size() ;i++ ){
        if( ans[i] )
            printf( (i % 2) ? "JUMP %I64d\n":"RUN %I64d\n" , ans[i]  );
    }
    return 0;
}


#include<bits/stdc++.h>
#define debug(x) cout<<#x<<"  : "<<x<<endl;
#define foreach(it,v) for(__typeof(v.begin()) it = v.begin(); it != v.end(); ++it)
#define pii pair<int ,int>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 10;
const int M = 128;
const int inf = 0x7fffffff;
const ll INF = 9E18;
const int mod = 1e9 + 7;
const int eps = 1e-7;

int a[maxn];
vector< pair<string , int> > ans;

int main()
{
    int n , m , s , d;
    scanf("%d%d%d%d",&n,&m,&s,&d);
    int last = 0 , cnt = 0;
    for(int i = 0 ; i < n ; i++ )
        scanf("%d",&a[i]);
    sort( a , a + n );
    int flag = 0;
    if( d <= 1 ){
        puts("IMPOSSIBLE");
        return 0;
    }
    for(int i = 0 ; i < n ; i++ ){
        if( cnt % 2 == 0 ){
            ans.push_back( make_pair( "RUN" , a[i] - 1 - last ) );
            last = a[i] - 1;
            cnt++;
        }
        else{
            int need = a[i] + 1;
            int pos = i;
            for(int j = i + 1 ; j < n ; j++ ){
                if( a[j] - a[j - 1] - 2 < s ){
                    need = a[j] + 1;
                    pos = j;
                }
                else break;
            }
            if( need - last > d ){
                flag = 1;
                break;
            }
            cnt++;
            i = pos;
            ans.push_back( make_pair( "JUMP" , need - last ) );
            last = a[pos] + 1;
        }
    }
    //debug(last)
    while( last < m ){
        if( cnt % 2 == 0 ){
            if( m - last < s )
                flag  = 1;
            else
                ans.push_back( make_pair( "RUN" , m - last ) );
            last = m;
            cnt++;
        }
        else{
            if( last + d >= m  ){
                ans.push_back( make_pair( "JUMP", m - last ) );
                last = m;
            }
            else{
                ans.push_back(  make_pair( "JUMP" , 1 ) );
                last++;
            }
            cnt++;
        }
    }
    if( flag )
    {
        puts("IMPOSSIBLE");
        return 0;
    }
    for(auto it : ans ){
        cout<<it.first<<" "<<it.second<<endl;
    }
    return 0;
}


#include<bits/stdc++.h>
#define debug(x) cout<<#x<<"  : "<<x<<endl;
#define foreach(it,v) for(__typeof(v.begin()) it = v.begin(); it != v.end(); ++it)
#define pii pair<int ,int>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 10;
const int M = 128;
const int inf = 0x7fffffff;
const ll INF = 9E18;
const int mod = 1e9 + 7;
const int eps = 1e-7;

ll a[maxn];
vector<ll> ans;

int main()
{
    ll n , m , s , d;
    cin>>n>>m>>s>>d;
    for(int i = 0 ; i < n ; i++ )
        cin>>a[i];
    sort( a , a + n );
    a[n] = m + 1;
    ll now  = a[0] - 1 , last = 0 , flag = 0;
    ans.push_back( now - last );
    for(int i = 0 ; i < n ; i++ ){
        if( now - last < s ){
            flag = 1;
            break;
        }
        int can = 0 , j;
        for(j = i + 1 ; j <= n ; j++ ){
            if( a[j] + 1 - now > d  )
                break;
            if( a[j] - a[j - 1] - 2 >= s || j == n ){
                can = 1;
                break;
            }
            i++;
        }
        last = a[j - 1] + 1;
        ans.push_back( last - now );
        now = a[j] - 1;
        //debug(now)
        ans.push_back( now - last );
    }
    if( flag ){
        puts("IMPOSSIBLE");
        return 0;
    }
    for(int i = 0 ; i < ans.size() ;i++ ){
        printf( (i % 2) ? "JUMP %I64d\n":"RUN %I64d\n" , ans[i]  );
    }
    return 0;
}


#include<bits/stdc++.h>
#define debug(x) cout<<#x<<"  : "<<x<<endl;
#define foreach(it,v) for(__typeof(v.begin()) it = v.begin(); it != v.end(); ++it)
#define pii pair<int ,int>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 10;
const int M = 128;
const int inf = 0x7fffffff;
const ll INF = 9E18;
const int mod = 1e9 + 7;
const int eps = 1e-7;

ll a[maxn];
vector<ll> ans;

int main()
{
    ll n , m , s , d;
    cin>>n>>m>>s>>d;
    for(int i = 0 ; i < n ; i++ )
        cin>>a[i];
    sort( a , a + n );
    a[n] = m + 1;
    ll now  = a[0] - 1 , last = 0 ;
    int  flag = 0;
    ans.push_back( now - last );
    for(int i = 0 ; i < n ; i++ ){
        if( now - last < s ){
            flag = 1;
            break;
        }
        int can = 0 , j;
        for(j = i + 1 ; j <= n ; j++ ){
            if( a[i] + 1 - now > d  ){
                break;
            }
            if( (a[j] - a[i] - 2 >= s) || (j == n) ){
                can = 1;
                break;
            }
            i++;
        }
        if( !can ){
            flag = 1;
            break;
        }
        last = a[j - 1] + 1;
        ans.push_back( last - now );
        now = a[j] - 1;
        //debug(now)
        ans.push_back( now - last );
    }
    if( flag ){
        puts("IMPOSSIBLE");
        return 0;
    }
    for(int i = 0 ; i < ans.size() ;i++ ){
        if( ans[i] )
            printf( (i % 2) ? "JUMP %I64d\n":"RUN %I64d\n" , ans[i]  );
    }
    return 0;
}


#include<bits/stdc++.h>
#define debug(x) cout<<#x<<"  : "<<x<<endl;
#define foreach(it,v) for(__typeof(v.begin()) it = v.begin(); it != v.end(); ++it)
#define pii pair<int ,int>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 10;
const int M = 128;
const int inf = 0x7fffffff;
const ll INF = 9E18;
const int mod = 1e9 + 7;
const int eps = 1e-7;

int a[maxn];
vector< pair<string , int> > ans;

int main()
{
    int n , m , s , d;
    scanf("%d%d%d%d",&n,&m,&s,&d);
    int last = 0 , cnt = 0;
    for(int i = 0 ; i < n ; i++ )
        scanf("%d",&a[i]);
    sort( a , a + n );
    int flag = 0;
    if( d <= 1 ){
        puts("IMPOSSIBLE");
        return 0;
    }
    for(int i = 0 ; i < n ; i++ ){
        if( cnt % 2 == 0 ){
            ans.push_back( make_pair( "RUN" , a[i] - 1 - last ) );
            last = a[i] - 1;
            cnt++;
        }
        else{
            int need = a[i] + 1;
            int pos = i;
            for(int j = i + 1 ; j < n ; j++ ){
                if( a[j] - a[j - 1] - 2 < s ){
                    need = a[j] + 1;
                    pos = j;
                }
                else break;
            }
            if( need - last > d ){
                flag = 1;
                break;
            }
            cnt++;
            i = pos;
            ans.push_back( make_pair( "JUMP" , need - last ) );
            last = a[pos] + 1;
        }
    }
    while( last < m ){
        if( cnt % 2 == 0 ){
            if( m - last < s )
                flag  = 1;
            else
                ans.push_back( make_pair( "RUN" , m - last ) );
            last = m;
            cnt++;
        }
        else{

            if( last + d >= m  ){
                ans.push_back( make_pair( "JUMP", m - last ) );
                last = m;
            }
            else{
                if( a[n - 1] > last ){
                    ans.push_back( make_pair("JUMP" , 2 ) );
                    last += 2;
                }
                else{
                    ans.push_back( make_pair( "JUMP" , 1 ) );
                    last++;
                }
            }
            cnt++;
        }
    }
    if( flag )
    {
        puts("IMPOSSIBLE");
        return 0;
    }
    for(auto it : ans ){
        cout<<it.first<<" "<<it.second<<endl;
    }
    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#define pb push_back
#define pf push_front
#define F first
#define S second
#define ins insert
#define int long long
#define fbo find_by_order
#define ook order_of_key
#define fo(it,s) for(set <int>::iterator it=s.begin();it!=s.end();++it)
using namespace std;
using namespace __gnu_pbds;
typedef pair<int,int> pii;
typedef pair<pii,int> piii;
typedef tree<int,null_type,less<int>,rb_tree_tag,
tree_order_statistics_node_update> indexed_set;
const int MAXN=2e5+1,INF=1e18+10,MOD=1e9+7;

int n,m,s,d,a[MAXN];
string st[3]={"IMPOSSIBLE","RUN","JUMP"};
vector <int> v;

int32_t main(){
	ios_base::sync_with_stdio(0);
	cin>>n>>m>>s>>d;
    for(int i=0;i<n;++i){
        cin>>a[i];
    }
    sort(a,a+n);
    n=unique(a,a+n)-a;
    int sum=0;
    for(int i=0;i<n-1;++i){
        if(a[i+1]-a[i]<=s){
            sum+=a[i+1]-a[i]+1;
        }else{
            if(sum>=d)   return cout<<st[0]<<endl,0;
            v.pb(-sum);
            v.pb(a[i+1]-a[i]-1);
            sum=0;
        }
    }
    if(sum+1>=d)    return cout<<st[0]<<endl,0;
    v.pb(-sum-1);
    if(a[0]!=1)    cout<<st[1]<<" "<<a[0]-1<<endl;
    for(int i=0;i<v.size();++i){
        if(v[i]<=0){
            cout<<st[2]<<" "<<-v[i]+1<<endl;
        }else{
            cout<<st[1]<<" "<<v[i]-1<<endl;
        }
    }
    if(a[n-1]!=m-1) cout<<st[1]<<" "<<m-a[n-1]-1<<endl;
	return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#define pb push_back
#define pf push_front
#define F first
#define S second
#define ins insert
#define int long long
#define fbo find_by_order
#define ook order_of_key
#define fo(it,s) for(set <int>::iterator it=s.begin();it!=s.end();++it)
using namespace std;
using namespace __gnu_pbds;
typedef pair<int,int> pii;
typedef pair<pii,int> piii;
typedef tree<int,null_type,less<int>,rb_tree_tag,
tree_order_statistics_node_update> indexed_set;
const int MAXN=2e5+1,INF=1e18+10,MOD=1e9+7;

int n,m,s,d,a[MAXN];
string st[3]={"IMPOSSIBLE","RUN","JUMP"};
vector <int> v;

int32_t main(){
	ios_base::sync_with_stdio(0);
	cin>>n>>m>>s>>d;
    for(int i=0;i<n;++i){
        cin>>a[i];
    }
    sort(a,a+n);
    n=unique(a,a+n)-a;
    int sum=0;
    for(int i=0;i<n-1;++i){
        if(a[i+1]-a[i]-1<=s){
            sum+=a[i+1]-a[i]+1;
        }else{
            if(sum>=d)   return cout<<st[0]<<endl,0;
            v.pb(-sum);
            v.pb(a[i+1]-a[i]-1);
            sum=0;
        }
    }
    if(sum+1>=d)    return cout<<st[0]<<endl,0;
    v.pb(-sum-1);
    if(a[0]!=1)    cout<<st[1]<<" "<<a[0]-1<<endl;
    for(int i=0;i<v.size();++i){
        if(v[i]<=0){
            cout<<st[2]<<" "<<-v[i]+1<<endl;
        }else{
            cout<<st[1]<<" "<<v[i]-1<<endl;
        }
    }
    if(a[n-1]!=m-1) cout<<st[1]<<" "<<m-a[n-1]-1<<endl;
	return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#define pb push_back
#define pf push_front
#define F first
#define S second
#define ins insert
#define int long long
#define fbo find_by_order
#define ook order_of_key
#define fo(it,s) for(set <int>::iterator it=s.begin();it!=s.end();++it)
using namespace std;
using namespace __gnu_pbds;
typedef pair<int,int> pii;
typedef pair<pii,int> piii;
typedef tree<int,null_type,less<int>,rb_tree_tag,
tree_order_statistics_node_update> indexed_set;
const int MAXN=2e5+1,INF=1e18+10,MOD=1e9+7;

int n,m,s,d,a[MAXN];
string st[3]={"IMPOSSIBLE","RUN","JUMP"};
vector <int> v;

int32_t main(){
	ios_base::sync_with_stdio(0);
	cin>>n>>m>>s>>d;
    for(int i=0;i<n;++i){
        cin>>a[i];
    }
    sort(a,a+n);
    n=unique(a,a+n)-a;
    int sum=0;
    for(int i=0;i<n-1;++i){
        //cout<<a[i]<<" ";
        if(a[i+1]-a[i]-1<=s){
            sum+=a[i+1]-a[i];
        }else{
            sum++;
            //cout<<sum;
            if(sum>=d)   return cout<<st[0]<<endl,0;
            if(sum>0)v.pb(-sum);
            v.pb(a[i+1]-a[i]-1);
            sum=0;
        }
        //cout<<endl;
    }
    if(sum+1>=d)    return cout<<st[0]<<endl,0;
    v.pb(-sum-1);
    if(a[0]!=1)    cout<<st[1]<<" "<<a[0]-1<<endl;
    for(int i=0;i<v.size();++i){
        if(v[i]<=0){
            cout<<st[2]<<" "<<-v[i]+1<<endl;
        }else{
            cout<<st[1]<<" "<<v[i]-1<<endl;
        }
    }
    if(a[n-1]!=m-1) cout<<st[1]<<" "<<m-a[n-1]-1<<endl;
	return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#define pb push_back
#define pf push_front
#define F first
#define S second
#define ins insert
#define int long long
#define fbo find_by_order
#define ook order_of_key
#define fo(it,s) for(set <int>::iterator it=s.begin();it!=s.end();++it)
using namespace std;
using namespace __gnu_pbds;
typedef pair<int,int> pii;
typedef pair<pii,int> piii;
typedef tree<int,null_type,less<int>,rb_tree_tag,
tree_order_statistics_node_update> indexed_set;
const int MAXN=2e5+1,INF=1e18+10,MOD=1e9+7;

int n,m,s,d,a[MAXN];
string st[3]={"IMPOSSIBLE","RUN","JUMP"};
vector <int> v;

int32_t main(){
	ios_base::sync_with_stdio(0);
	cin>>n>>m>>s>>d;
    for(int i=0;i<n;++i){
        cin>>a[i];
    }
    sort(a,a+n);
    n=unique(a,a+n)-a;
    int sum=0;
    for(int i=0;i<n-1;++i){
        //cout<<a[i]<<" ";
        if(a[i+1]-a[i]-1<=s){
            sum+=a[i+1]-a[i];
        }else{
            sum++;
            //cout<<sum;
            if(sum>=d)   return cout<<st[0]<<endl,0;
            if(sum>0)v.pb(-sum);
            v.pb(a[i+1]-a[i]-1);
            sum=0;
        }
        //cout<<endl;
    }
    if(sum+1>=d)    return cout<<st[0]<<endl,0;
    v.pb(-sum-1);
    if(a[0]!=1&&a[0]-1>=s)    cout<<st[1]<<" "<<a[0]-1<<endl;
    else           return cout<<st[0]<<endl,0;
    for(int i=0;i<v.size();++i){
        if(v[i]<=0){
            cout<<st[2]<<" "<<-v[i]+1<<endl;
        }else{
            cout<<st[1]<<" "<<v[i]-1<<endl;
        }
    }
    if(a[n-1]!=m-1) cout<<st[1]<<" "<<m-a[n-1]-1<<endl;
	return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#define pb push_back
#define pf push_front
#define F first
#define S second
#define ins insert
#define int long long
#define fbo find_by_order
#define ook order_of_key
#define fo(it,s) for(set <int>::iterator it=s.begin();it!=s.end();++it)
using namespace std;
using namespace __gnu_pbds;
typedef pair<int,int> pii;
typedef pair<pii,int> piii;
typedef tree<int,null_type,less<int>,rb_tree_tag,
tree_order_statistics_node_update> indexed_set;
const int MAXN=2e5+1,INF=1e18+10,MOD=1e9+7;

int n,m,s,d,a[MAXN];
string st[3]={"IMPOSSIBLE","RUN","JUMP"};
vector <int> v;

int32_t main(){
	ios_base::sync_with_stdio(0);
	cin>>n>>m>>s>>d;
    for(int i=0;i<n;++i){
        cin>>a[i];
    }
    sort(a,a+n);
    n=unique(a,a+n)-a;
    int sum=0;
    for(int i=0;i<n-1;++i){
        //cout<<a[i]<<" ";
        if(a[i+1]-a[i]-1<=s){
            sum+=a[i+1]-a[i];
        }else{
            sum++;
            //cout<<sum;
            if(sum>=d)   return cout<<st[0]<<endl,0;
            if(sum>0)v.pb(-sum);
            v.pb(a[i+1]-a[i]-1);
            sum=0;
        }
        //cout<<endl;
    }
    if(sum+1>=d)    return cout<<st[0]<<endl,0;
    v.pb(-sum-1);
    if(a[0]!=1)    cout<<st[1]<<" "<<a[0]-1<<endl;
    else           return cout<<st[0]<<endl,0;
    for(int i=0;i<v.size();++i){
        if(v[i]<=0){
            cout<<st[2]<<" "<<-v[i]+1<<endl;
        }else{
            cout<<st[1]<<" "<<v[i]-1<<endl;
        }
    }
    if(a[n-1]!=m-1) cout<<st[1]<<" "<<m-a[n-1]-1<<endl;
	return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#define pb push_back
#define pf push_front
#define F first
#define S second
#define ins insert
#define int long long
#define fbo find_by_order
#define ook order_of_key
#define fo(it,s) for(set <int>::iterator it=s.begin();it!=s.end();++it)
using namespace std;
using namespace __gnu_pbds;
typedef pair<int,int> pii;
typedef pair<pii,int> piii;
typedef tree<int,null_type,less<int>,rb_tree_tag,
tree_order_statistics_node_update> indexed_set;
const int MAXN=2e5+1,INF=1e18+10,MOD=1e9+7;

int n,m,s,d,a[MAXN];
string st[3]={"IMPOSSIBLE","RUN","JUMP"};
vector <int> v;

int32_t main(){
	ios_base::sync_with_stdio(0);
	cin>>n>>m>>s>>d;
    for(int i=0;i<n;++i){
        cin>>a[i];
    }
    sort(a,a+n);
    int sum=0;
    for(int i=0;i<n-1;++i){
        if(a[i+1]-a[i]<=s){
            sum+=a[i+1]-a[i]+1;
        }else{
            if(sum>=d)   return cout<<st[0]<<endl,0;
            v.pb(-sum);
            v.pb(a[i+1]-a[i]-1);
            sum=0;
        }
    }
    if(sum+1>=d)    return cout<<st[0]<<endl,0;
    v.pb(-sum-1);
   // for(int i=0;i<v.size();++i) cout<<v[i]<<" ";
    //return cout<<0<<endl,0;
    if(a[0]!=1)    cout<<st[1]<<" "<<a[0]-1<<endl;
    for(int i=0;i<v.size();++i){
        if(v[i]<=0){
            cout<<st[2]<<" "<<-v[i]+1<<endl;
        }else{
            cout<<st[1]<<" "<<v[i]-1<<endl;
        }
    }
    if(a[n-1]!=m-1) cout<<st[1]<<" "<<m-a[n-1]-1<<endl;
	return 0;
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <unordered_set>
#include <algorithm>
using namespace std;

int n, m, s, d;
int dp[1000000];
bool par[1000000];
bool par2[1000000];
int x[1000000];
vector < pair <int, int> > ans;

int main()
{
    ios_base::sync_with_stdio(false);
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    cin >> n >> m >> s >> d;

    if (d == 1)
    {
        cout << "IMPOSSIBLE" << endl;
        return 0;
    }

    for (int i = 1; i <= n; i++)
    {
        cin >> x[i];
    }

    sort(x + 1, x + n + 1);

    for (int i = 1; i <= n; i++)
    {
        int llen = x[i] - x[i - 1] - 2;
        if (i == 1)
        {
            llen = x[i] - x[i - 1] - 1;
        }

        if (llen >= s)
        {
            dp[i] = x[i] - 1;
            par[i] = true;
        } else
        {
            int ll = dp[i - 1];

            if (i == 1)
            {
                ll = 0;
            }

            if (x[i] - ll + 1 > d)
            {
                cout << "IMPOSSIBLE" << endl;
                return 0;
            } else
            {
                dp[i] = dp[i - 1];
                par2[i - 1] = true;
            }
        }
    }

    if (m != x[n] + 1)
    {
        ans.push_back({0, m - x[n] - 1});
    }

    for (int i = n; i >= 1; i--)
    {
        if (par[i] && par2[i])
        {
            if (i > 1)
            {
                ans.push_back({0, dp[i] - x[i - 1] - 1});
            } else
            {
                ans.push_back({0, dp[i] - x[i - 1]});
            }
        } else
        if (par[i])
        {
            ans.push_back({1, x[i] + 1 - dp[i]});

            if (i > 1)
            {
                ans.push_back({0, dp[i] - x[i - 1] - 1});
            } else
            {
                ans.push_back({0, dp[i] - x[i - 1]});
            }
        } else
        {
            if (i == n || par[i + 1])
            {
                ans.push_back({1, x[i] + 1 - dp[i]});
            }
        }
    }

    for (int i = int(ans.size()) - 1; i >= 0; i--)
    {
        if (ans[i].first == 0)
        {
            cout << "RUN" << " " << ans[i].second << endl;
        } else
        {
            cout << "JUMP" << " " << ans[i].second << endl;
        }
    }
    return 0;
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <unordered_set>
#include <algorithm>
using namespace std;

int n, m, s, d;
int dp[1000000];
bool par[1000000];
bool par2[1000000];
int x[1000000];
vector < pair <int, int> > ans;

int main()
{
    ios_base::sync_with_stdio(false);
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    cin >> n >> m >> s >> d;
    for (int i = 1; i <= n; i++)
    {
        cin >> x[i];
    }

    sort(x + 1, x + n + 1);

    for (int i = 1; i <= n; i++)
    {
        int llen = x[i] - x[i - 1] - 2;
        if (i == 1)
        {
            llen = x[i] - x[i - 1] - 1;
        }

        if (llen >= s)
        {
            dp[i] = x[i] - 1;
            par[i] = true;
        } else
        {
            int ll = dp[i - 1];

            if (i == 1)
            {
                ll = 0;
            }

            if (x[i] - ll + 1 > d)
            {
                cout << "IMPOSSIBLE" << endl;
                return 0;
            } else
            {
                dp[i] = dp[i - 1];
                par2[i - 1] = true;
            }
        }
    }

    if (m != x[n] + 1)
    {
        ans.push_back({0, m - x[n] - 1});
    }

    for (int i = n; i >= 1; i--)
    {
        if (par[i] && par2[i])
        {
            if (i > 1)
            {
                ans.push_back({0, dp[i] - x[i - 1] - 1});
            } else
            {
                ans.push_back({0, dp[i] - x[i - 1]});
            }
        } else
        if (par[i])
        {
            ans.push_back({1, x[i] + 1 - dp[i]});

            if (i > 1)
            {
                ans.push_back({0, dp[i] - x[i - 1] - 1});
            } else
            {
                ans.push_back({0, dp[i] - x[i - 1]});
            }
        } else
        {
            if (i == n || par[i + 1])
            {
                ans.push_back({1, x[i] + 1 - dp[i]});
            } else
            if (i == 1 || par[i - 1])
            {
                if (i > 1)
                {
                    ans.push_back({0, dp[i] - x[i - 1] - 1});
                } else
                {
                    ans.push_back({0, dp[i] - x[i - 1]});
                }
            }
        }
    }

    for (int i = int(ans.size()) - 1; i >= 0; i--)
    {
        if (ans[i].first == 0)
        {
            cout << "RUN" << " " << ans[i].second << endl;
        } else
        {
            cout << "JUMP" << " " << ans[i].second << endl;
        }
    }
    return 0;
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <unordered_set>
#include <algorithm>
using namespace std;

int n, m, s, d;
int dp[1000000];
bool par[1000000];
bool par2[1000000];
int x[1000000];
vector < pair <int, int> > ans;

int main()
{
    ios_base::sync_with_stdio(false);
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    cin >> n >> m >> s >> d;

    if (d == 1)
    {
        cout << "IMPOSSIBLE" << endl;
        return 0;
    }

    for (int i = 1; i <= n; i++)
    {
        cin >> x[i];
    }

    sort(x + 1, x + n + 1);

    for (int i = 1; i <= n; i++)
    {
        int llen = x[i] - x[i - 1] - 2;
        if (i == 1)
        {
            llen = x[i] - x[i - 1] - 1;
        }

        if (llen >= s)
        {
            dp[i] = x[i] - 1;
            par[i] = true;
        } else
        {
            int ll = dp[i - 1];

            if (i == 1)
            {
                ll = 0;
            }

            if (x[i] - ll + 1 > d)
            {
                cout << "IMPOSSIBLE" << endl;
                return 0;
            } else
            {
                dp[i] = dp[i - 1];
                par2[i - 1] = true;
            }
        }
    }

    if (m != x[n] + 1)
    {
        ans.push_back({0, m - x[n] - 1});
    }

    for (int i = n; i >= 1; i--)
    {
        if (par[i] && par2[i])
        {
            if (i > 1)
            {
                ans.push_back({0, dp[i] - x[i - 1] - 1});
            } else
            {
                ans.push_back({0, dp[i] - x[i - 1]});
            }
        } else
        if (par[i])
        {
            ans.push_back({1, x[i] + 1 - dp[i]});

            if (i > 1)
            {
                ans.push_back({0, dp[i] - x[i - 1] - 1});
            } else
            {
                ans.push_back({0, dp[i] - x[i - 1]});
            }
        } else
        {
            if (i == n || par[i + 1])
            {
                ans.push_back({1, x[i] + 1 - dp[i]});
            } else
            if (i == 1 || par[i - 1])
            {
                if (i > 1)
                {
                    ans.push_back({0, dp[i] - x[i - 1] - 1});
                } else
                {
                    ans.push_back({0, dp[i] - x[i - 1]});
                }
            }
        }
    }

    for (int i = int(ans.size()) - 1; i >= 0; i--)
    {
        if (ans[i].first == 0)
        {
            cout << "RUN" << " " << ans[i].second << endl;
        } else
        {
            cout << "JUMP" << " " << ans[i].second << endl;
        }
    }
    return 0;
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <unordered_set>
#include <algorithm>
using namespace std;

int n, m, s, d;
int dp[1000000];
bool par[1000000];
bool par2[1000000];
int x[1000000];
vector < pair <int, int> > ans;

int main()
{
    ios_base::sync_with_stdio(false);
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    cin >> n >> m >> s >> d;

    if (d == 1)
    {
        cout << "IMPOSSIBLE" << endl;
        return 0;
    }

    for (int i = 1; i <= n; i++)
    {
        cin >> x[i];
    }

    sort(x + 1, x + n + 1);

    for (int i = 1; i <= n; i++)
    {
        int llen = x[i] - x[i - 1] - 2;

        if (i == 1)
        {
            llen = x[i] - x[i - 1] - 1;
        }

        if (llen >= s)
        {
            dp[i] = x[i] - 1;
            par[i] = true;
        } else
        {
            int ll = dp[i - 1];

            if (i == 1)
            {
                ll = 0;
            }

            if (x[i] - ll + 1 > d)
            {
                cout << "IMPOSSIBLE" << endl;
                return 0;
            } else
            {
                dp[i] = dp[i - 1];
                par2[i - 1] = true;
            }
        }
    }

    if (m != x[n] + 1)
    {
        ans.push_back({0, m - x[n] - 1});
    }

    for (int i = n; i >= 1; i--)
    {
        if (par[i] && par2[i])
        {
            if (i > 1)
            {
                ans.push_back({0, dp[i] - x[i - 1] - 1});
            } else
            {
                ans.push_back({0, dp[i] - x[i - 1]});
            }
        } else
        if (par[i])
        {
            if (i > 1)
            {
                ans.push_back({1, x[i] + 1 - dp[i]});
            }

            if (i > 1)
            {
                ans.push_back({0, dp[i] - x[i - 1] - 1});
            } else
            {
                ans.push_back({0, dp[i] - x[i - 1]});
            }
        } else
        {
            if (i == n || par[i + 1])
            {
                ans.push_back({1, x[i] + 1 - dp[i]});
            }
        }
    }

    for (int i = int(ans.size()) - 1; i >= 0; i--)
    {
        if (ans[i].first == 0)
        {
            cout << "RUN" << " " << ans[i].second << endl;
        } else
        {
            cout << "JUMP" << " " << ans[i].second << endl;
        }
    }
    return 0;
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

int n, m, s, d;
int dp[1000000];
bool par[1000000];
bool par2[1000000];
int x[1000000];
vector < pair <int, int> > ans;

int main()
{
    ios_base::sync_with_stdio(false);
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    cin >> n >> m >> s >> d;

    if (d == 1)
    {
        cout << "IMPOSSIBLE" << endl;
        return 0;
    }

    for (int i = 1; i <= n; i++)
    {
        cin >> x[i];
    }

    sort(x + 1, x + n + 1);

    for (int i = 1; i <= n; i++)
    {
        int llen = x[i] - x[i - 1] - 2;

        if (i == 1)
        {
            llen = x[i] - x[i - 1] - 1;
        }

        if (llen >= s)
        {
            dp[i] = x[i] - 1;
            par[i] = true;
        } else
        if (i == 1)
        {
            cout << "IMPOSSIBLE" << endl;
            return 0;
        } else
        {
            int ll = dp[i - 1];

            if (i == 1)
            {
                ll = 0;
            }

            if (x[i] - ll + 1 > d)
            {
                cout << "IMPOSSIBLE" << endl;
                return 0;
            } else
            {
                dp[i] = dp[i - 1];
                par2[i - 1] = true;
            }
        }
    }

    if (m != x[n] + 1)
    {
        ans.push_back({0, m - x[n] - 1});
    }

    for (int i = n; i >= 1; i--)
    {
        if (par[i] && par2[i])
        {
            if (i > 1)
            {
                ans.push_back({0, dp[i] - x[i - 1] - 1});
            } else
            {
                ans.push_back({0, dp[i] - x[i - 1]});
            }
        } else
        if (par[i])
        {
            ans.push_back({1, x[i] + 1 - dp[i]});

            if (i > 1)
            {
                ans.push_back({0, dp[i] - x[i - 1] - 1});
            } else
            {
                ans.push_back({0, dp[i] - x[i - 1]});
            }
        } else
        {
            if (i == n || par[i + 1])
            {
                ans.push_back({1, x[i] + 1 - dp[i]});
            }
        }
    }

    for (int i = int(ans.size()) - 1; i >= 0; i--)
    {
        if (ans[i].first == 0)
        {
            cout << "RUN" << " " << ans[i].second << endl;
        } else
        {
            cout << "JUMP" << " " << ans[i].second << endl;
        }
    }
    return 0;
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <unordered_set>
#include <algorithm>
using namespace std;

int n, m, s, d;
int dp[1000000];
bool par[1000000];
bool par2[1000000];
int x[1000000];
vector < pair <int, int> > ans;

int main()
{
    ios_base::sync_with_stdio(false);
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    cin >> n >> m >> s >> d;
    for (int i = 1; i <= n; i++)
    {
        cin >> x[i];
    }

    sort(x + 1, x + n + 1);

    for (int i = 1; i <= n; i++)
    {
        if (x[i] - x[i - 1] - 2 >= s)
        {
            dp[i] = x[i] - 1;
            par[i] = true;
        } else
        {
            int ll = dp[i - 1];

            if (i == 1)
            {
                ll = 0;
            }

            if (x[i] - ll + 1 > d)
            {
                cout << "IMPOSSIBLE" << endl;
                return 0;
            } else
            {
                dp[i] = dp[i - 1];
                par2[i - 1] = true;
            }
        }
    }

    if (m != x[n] + 1)
    {
        ans.push_back({0, m - x[n] - 1});
    }

    for (int i = n; i >= 1; i--)
    {
        if (par[i] && par2[i])
        {
            if (i > 1)
            {
                ans.push_back({0, dp[i] - x[i - 1] - 1});
            } else
            {
                ans.push_back({0, dp[i] - x[i - 1]});
            }
        } else
        if (par[i])
        {
            ans.push_back({1, x[i] + 1 - dp[i]});

            if (i > 1)
            {
                ans.push_back({0, dp[i] - x[i - 1] - 1});
            } else
            {
                ans.push_back({0, dp[i] - x[i - 1]});
            }
        } else
        {
            if (i == n || par[i + 1])
            {
                ans.push_back({1, x[i] + 1 - dp[i]});
            } else
            if (i == 1 || par[i - 1])
            {
                if (i > 1)
                {
                    ans.push_back({0, dp[i] - x[i - 1] - 1});
                } else
                {
                    ans.push_back({0, dp[i] - x[i - 1]});
                }
            }
        }
    }

    for (int i = int(ans.size()) - 1; i >= 0; i--)
    {
        if (ans[i].first == 0)
        {
            cout << "RUN" << " " << ans[i].second << endl;
        } else
        {
            cout << "JUMP" << " " << ans[i].second << endl;
        }
    }
    return 0;
}


#include<bits/stdc++.h>
#define f first
#define s second
#define t triple
#define mp make_pair
#define pb push_back
#define ll long long
#define sqr(x) (x)*(x)
#define all(a) (a).begin(),(a).end()

using namespace std;

struct tripl{
    ll first,second,triple;
};

tripl make_tripl(ll x, ll y, ll z){
    tripl tr;
    tr.f=x;
    tr.s=y;
    tr.t=z;
    return tr;
}

vector<tripl> vec;
vector<pair<char, ll> > ans;
long long n,m,S,d,x[200001],pos;

bool run(ll pos, ll l){
        if(x[l+1]>=pos && x[l+1]<=pos+S)
            return false;
    return true;
}

ll fnd(ll X, ll l){
    for(int i=n-1; i>=l; i--)
        if(x[i]<X)
            return i;
}

int main(){
    cin>>n>>m>>S>>d;
    for(int i=0; i<n; i++){
        cin>>x[i];
    }
    sort(x,x+n);
    ll start = 0;
    for(int i=0; i<n; i++){
       //cout<<start<<" "<<x[i]<<endl;
       if((x[i]-1-start)<S){
         cout<<"IMPOSSIBLE";
            return 0;
       }
        ans.pb(mp('r',x[i]-1-start));
        start=x[i]-1;
        ll r=fnd(start+d,i+1);
        for(int j=r; j>=i; j--){
            if(run(x[j]+1,j)){
                ans.pb(mp('j',x[j]+1-x[i]+1));
                if(x[j]+1-x[i]+1>d){
                    cout<<"IMPOSSIBLE";
                    return 0;
                }
                start=x[j]+1;
                i=j;
                break;
            }else{
            if(j==i){
                cout<<"IMPOSSIBLE";
                    return 0;

            }
            }
        }
    }
        if(ans.empty()){
        cout<<"IMPOSSIBLE";
            return 0;
    }
       for(int i=0; i<ans.size(); i++){
            if(ans[i].f=='r')
                cout<<"RUN ";
            else
                cout<<"JUMP ";
            cout<<ans[i].s;
            if(i<ans.size()-1)
                cout<<endl;
            if(i==ans.size()-1 && start!=m)
                cout<<endl;
       }
       if(start!=m)
        cout<<"RUN "<<m-start;
}


#include<bits/stdc++.h>
#define f first
#define s second
#define t triple
#define mp make_pair
#define pb push_back
#define ll long long

using namespace std;

ll n,m,S,d,x[300001];

bool run(ll pos, ll l){
    if(x[l+1]>=pos && x[l+1]<=pos+S)
        return false;
    return true;
}

ll fnd(ll X,ll l){
    for(int i=n-1; i>=0; i--){
            //cout<<i<<" "<<x[i]<<endl;
        if(x[i]<X && run(x[i]+1,i))
            return i;
    }
    return -1;
}

vector<pair<char, ll> > ans;

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin>>n>>m>>S>>d;
    for(int i=0; i<n; i++)
        cin>>x[i];
    sort(x,x+n);
    ll start=0;
    for(int i=0; i<n; i++){
        ans.pb(mp('r',x[i]-1-start));
        start=x[i]-1;
        ll r=fnd(start+d,i);
        //cout<<r<<endl;
        if(r==-1 || r<i){
            cout<<"IMPOSSIBLE";
            return 0;
        }
        ans.pb(mp('j',x[r]+1-start));
        i=r;
        start=x[r]+1;
    }
    if(ans.empty()){
            cout<<"IMPOSSIBLE";
            return 0;
        }
    for(int i=0; i<ans.size(); i++){
        if(ans[i].f=='r')
            cout<<"RUN ";
        else
            cout<<"JUMP ";
        cout<<ans[i].s<<endl;
    }
    if(start!=m)
        cout<<"RUN "<<m-start;
}


#include<bits/stdc++.h>
#define f first
#define s second
#define t triple
#define mp make_pair
#define pb push_back
#define ll long long
#define sqr(x) (x)*(x)
#define all(a) (a).begin(),(a).end()

using namespace std;

struct tripl{
    ll first,second,triple;
};

tripl make_tripl(ll x, ll y, ll z){
    tripl tr;
    tr.f=x;
    tr.s=y;
    tr.t=z;
    return tr;
}

vector<tripl> vec;
vector<pair<char, ll> > ans;
long long n,m,S,d,x[200001],pos;

bool run(ll pos, ll l){
        if(x[l+1]>=pos && x[l+1]<=pos+S)
            return false;
    return true;
}

ll fnd(ll X){
    ll l=0;
    ll r=n-1;
    while(r-l>1){
        ll mid=(r+l)/2;
        if(x[mid]>X)
            r=mid;
        else l=mid;
    }
    if(x[r]<X)
        return r;
    return l;
}

int main(){
    cin>>n>>m>>S>>d;
    for(int i=0; i<n; i++){
        cin>>x[i];
    }
    sort(x,x+n);
    ll start = 0;
    for(int i=0; i<n; i++){
       //cout<<start<<" "<<x[i]<<endl;
       if((x[i]-1-start)<S){
         cout<<"IMPOSSIBLE";
            return 0;
       }
        ans.pb(mp('r',x[i]-1-start));
        start=x[i]-1;
        ll r=fnd(start+d);
        for(int j=r; j>=i; j--){
            if(run(x[j]+1,j)){
                ans.pb(mp('j',x[j]+1-x[i]+1));
                if(x[j]+1-x[i]+1>d){
                    cout<<"IMPOSSIBLE";
                    return 0;
                }
                start=x[j]+1;
                i=j;
                break;
            }else{
            if(j==i){
                cout<<"IMPOSSIBLE";
                    return 0;

            }
            }
        }
    }
    /**for(int i=0; i<n; i++){
        if(vec.empty()){
            vec.pb(make_tripl(x[i],x[i],1));
            continue;
        }
        if(vec[pos].s+1==x[i] || (x[i]-vec[pos].f+2<=d)){
            vec[pos].s=x[i];
            vec[pos].t=x[i]-vec[pos].f+1;
        }else{
            vec.pb(make_tripl(x[i],x[i],1));
            pos++;
        }
        if(vec[pos].t>d){
            cout<<"IMPOSSIBLE";
            return 0;
        }
    }
    ll start=0;
    for(int i=0; i<vec.size(); i++){
        ans.pb(mp('r',vec[i].f-start-1));
        if(vec[i].f-start-1>=S){
            start=vec[i].s+1;
            ans.pb(mp('j',vec[i].triple+1));
        }else{
             cout<<"IMPOSSIBLE";
            return 0;
        }
    }**/
       for(int i=0; i<ans.size(); i++){
            if(ans[i].f=='r')
                cout<<"RUN ";
            else
                cout<<"JUMP ";
            cout<<ans[i].s<<endl;
       }
       if(start!=m)
        cout<<"RUN "<<m-start;

}


#include<bits/stdc++.h>
#define f first
#define s second
#define t triple
#define mp make_pair
#define pb push_back
#define ll long long
#define sqr(x) (x)*(x)
#define all(a) (a).begin(),(a).end()

using namespace std;

struct tripl{
    ll first,second,triple;
};

tripl make_tripl(ll x, ll y, ll z){
    tripl tr;
    tr.f=x;
    tr.s=y;
    tr.t=z;
    return tr;
}

vector<tripl> vec;
vector<pair<char, ll> > ans;
long long n,m,S,d,x[200001],pos;

bool run(ll pos, ll l){
        if(x[l+1]>=pos && x[l+1]<=pos+S)
            return false;
    return true;
}

ll fnd(ll X, int l){
    for(int i=n-1;i>=l; i--)
         if(x[i]<X)
             return i;
}

int main(){
    cin>>n>>m>>S>>d;
    for(int i=0; i<n; i++){
        cin>>x[i];
    }
    sort(x,x+n);
    ll start = 0;
    for(int i=0; i<n; i++){
       //cout<<start<<" "<<x[i]<<endl;
       if((x[i]-1-start)<S){
         cout<<"IMPOSSIBLE";
            return 0;
       }
        ans.pb(mp('r',x[i]-1-start));
        start=x[i]-1;
        ll r=fnd(start+d,i);
        for(int j=r; j>=i; j--){
            if(run(x[j]+1,j)){
                ans.pb(mp('j',x[j]+1-x[i]+1));
                if(x[j]+1-x[i]+1>d){
                    cout<<"IMPOSSIBLE";
                    return 0;
                }
                start=x[j]+1;
                i=j;
                break;
            }else{
            if(j==i){
                cout<<"IMPOSSIBLE";
                    return 0;

            }
            }
        }
    }
        if(ans.empty()){
        cout<<"IMPOSSIBLE";
            return 0;
    }
       for(int i=0; i<ans.size(); i++){
            if(ans[i].f=='r')
                cout<<"RUN ";
            else
                cout<<"JUMP ";
            cout<<ans[i].s;
            if(i<ans.size()-1)
                cout<<endl;
            if(i==ans.size()-1 && start!=m)
                cout<<endl;
       }
       if(start!=m)
        cout<<"RUN "<<m-start;
}


#include<bits/stdc++.h>
#define f first
#define s second
#define t triple
#define mp make_pair
#define pb push_back
#define ll long long
#define sqr(x) (x)*(x)
#define all(a) (a).begin(),(a).end()

using namespace std;

struct tripl{
    ll first,second,triple;
};

tripl make_tripl(ll x, ll y, ll z){
    tripl tr;
    tr.f=x;
    tr.s=y;
    tr.t=z;
    return tr;
}

vector<tripl> vec;
vector<pair<char, ll> > ans;
long long n,m,S,d,x[200001],pos;

bool run(ll pos, ll l){
        if(x[l+1]>=pos && x[l+1]<=pos+S)
            return false;
    return true;
}

ll fnd(ll X){
    for(int i=n-1;i>=0; i--)
         if(x[i]<=X && run(x[i],i))
             return i;
}

int main(){
    cin>>n>>m>>S>>d;
    for(int i=0; i<n; i++){
        cin>>x[i];
    }
    sort(x,x+n);
    ll start = 0;
    for(int i=0; i<n; i++){
       //cout<<start<<" "<<x[i]<<endl;
       if((x[i]-1-start)<S){
         cout<<"IMPOSSIBLE";
            return 0;
       }
        ans.pb(mp('r',x[i]-1-start));
        start=x[i]-1;
        ll r=fnd(start+d);
        for(int j=r; j>=i; j--){
            if(run(x[j]+1,j)){
                ans.pb(mp('j',x[j]+1-x[i]+1));
                if(x[j]+1-x[i]+1>d){
                    cout<<"IMPOSSIBLE";
                    return 0;
                }
                start=x[j]+1;
                i=j;
                break;
            }else{
            if(j==i){
                cout<<"IMPOSSIBLE";
                    return 0;

            }
            }
        }
    }
        if(ans.empty()){
        cout<<"IMPOSSIBLE";
            return 0;
    }
       for(int i=0; i<ans.size(); i++){
            if(ans[i].f=='r')
                cout<<"RUN ";
            else
                cout<<"JUMP ";
            cout<<ans[i].s;
            if(i<ans.size()-1)
                cout<<endl;
            if(i==ans.size()-1 && start!=m)
                cout<<endl;
       }
       if(start!=m)
        cout<<"RUN "<<m-start;
}


#include<bits/stdc++.h>
#define f first
#define s second
#define t triple
#define mp make_pair
#define pb push_back
#define ll long long
#define sqr(x) (x)*(x)
#define all(a) (a).begin(),(a).end()

using namespace std;

struct tripl{
    ll first,second,triple;
};

tripl make_tripl(ll x, ll y, ll z){
    tripl tr;
    tr.f=x;
    tr.s=y;
    tr.t=z;
    return tr;
}

vector<tripl> vec;
vector<pair<char, ll> > ans;
long long n,m,S,d,x[200001],pos;

bool run(ll pos, ll l){
        if(x[l+1]>=pos && x[l+1]<=pos+S)
            return false;
    return true;
}

ll fnd(ll X){
    for(int i=n-1;i>=0; i--)
         if(x[i]<X && run(x[i]+1,i))
             return i;
}

int main(){
    cin>>n>>m>>S>>d;
    for(int i=0; i<n; i++){
        cin>>x[i];
    }
    sort(x,x+n);
    ll start = 0;
    for(int i=0; i<n; i++){
       //cout<<start<<" "<<x[i]<<endl;
       if((x[i]-1-start)<S){
         cout<<"IMPOSSIBLE";
            return 0;
       }
        ans.pb(mp('r',x[i]-1-start));
        start=x[i]-1;
        ll r=fnd(start+d);
        for(int j=r; j>=i; j--){
            if(run(x[j]+1,j)){
                ans.pb(mp('j',x[j]+1-x[i]+1));
                if(x[j]+1-x[i]+1>d){
                    cout<<"IMPOSSIBLE";
                    return 0;
                }
                start=x[j]+1;
                i=j;
                break;
            }else{
            if(j==i){
                cout<<"IMPOSSIBLE";
                    return 0;

            }
            }
        }
    }
        if(ans.empty()){
        cout<<"IMPOSSIBLE";
            return 0;
    }
       for(int i=0; i<ans.size(); i++){
            if(ans[i].f=='r')
                cout<<"RUN ";
            else
                cout<<"JUMP ";
            cout<<ans[i].s;
            if(i<ans.size()-1)
                cout<<endl;
            if(i==ans.size()-1 && start!=m)
                cout<<endl;
       }
       if(start!=m)
        cout<<"RUN "<<m-start;
}


#include<bits/stdc++.h>
#define f first
#define s second
#define t triple
#define mp make_pair
#define pb push_back
#define ll long long

using namespace std;

ll n,m,S,d,x[300001];

bool run(ll pos, ll l){
    if(x[l+1]>=pos && x[l+1]<=pos+S)
        return false;
    return true;
}

ll fnd(ll X,ll l){
    for(int i=n-1; i>=0; i--){
            //cout<<i<<" "<<x[i]<<endl;
        if(x[i]<X && run(x[i]+1,i))
            return i;
    }
    return -1;
}

vector<pair<char, ll> > ans;

int main(){
    cin>>n>>m>>S>>d;
    for(int i=0; i<n; i++)
        cin>>x[i];
    sort(x,x+n);
    ll start=0;
    for(int i=0; i<n; i++){
        ans.pb(mp('r',x[i]-1-start));
        start=x[i]-1;
        ll r=fnd(start+d,i);
        //cout<<r<<endl;
        if(r==-1 || r<i){
            cout<<"IMPOSSIBLE";
            return 0;
        }
        ans.pb(mp('j',x[r]+1-start));
        i=r;
        start=x[r]+1;
    }
    if(ans.empty()){
            cout<<"IMPOSSIBLE";
            return 0;
        }
    for(int i=0; i<ans.size(); i++){
        if(ans[i].f=='r')
            cout<<"RUN ";
        else
            cout<<"JUMP ";
        cout<<ans[i].s<<endl;
    }
    if(start!=m)
        cout<<"RUN "<<m-start;
}


#include<bits/stdc++.h>
#define f first
#define s second
#define t triple
#define mp make_pair
#define pb push_back
#define ll long long
#define sqr(x) (x)*(x)
#define all(a) (a).begin(),(a).end()

using namespace std;

struct tripl{
    ll first,second,triple;
};

tripl make_tripl(ll x, ll y, ll z){
    tripl tr;
    tr.f=x;
    tr.s=y;
    tr.t=z;
    return tr;
}

vector<tripl> vec;
vector<pair<char, ll> > ans;
long long n,m,S,d,x[200001],pos;

bool run(ll pos, ll l){
        if(x[l+1]>=pos && x[l+1]<=pos+S)
            return false;
    return true;
}

ll fnd(ll X){
    ll l=0;
    ll r=n-1;
    while(r-l>1){
        ll mid=(r+l)/2;
        if(x[mid]>X)
            r=mid;
        else l=mid;
    }
    if(x[r]<X)
        return r;
    return l;
}

int main(){
    cin>>n>>m>>S>>d;
    for(int i=0; i<n; i++){
        cin>>x[i];
    }
    sort(x,x+n);
    ll start = 0;
    for(int i=0; i<n; i++){
       //cout<<start<<" "<<x[i]<<endl;
       if((x[i]-1-start)<S){
         cout<<"IMPOSSIBLE";
            return 0;
       }
        ans.pb(mp('r',x[i]-1-start));
        start=x[i]-1;
        ll r=fnd(start+d);
        for(int j=r; j>=i; j--){
            if(run(x[j]+1,j)){
                ans.pb(mp('j',x[j]+1-x[i]+1));
                if(x[j]+1-x[i]+1>d){
                    cout<<"IMPOSSIBLE";
                    return 0;
                }
                start=x[j]+1;
                i=j;
                break;
            }else{
            if(j==i){
                cout<<"IMPOSSIBLE";
                    return 0;

            }
            }
        }
    }
    /**for(int i=0; i<n; i++){
        if(vec.empty()){
            vec.pb(make_tripl(x[i],x[i],1));
            continue;
        }
        if(vec[pos].s+1==x[i] || (x[i]-vec[pos].f+2<=d)){
            vec[pos].s=x[i];
            vec[pos].t=x[i]-vec[pos].f+1;
        }else{
            vec.pb(make_tripl(x[i],x[i],1));
            pos++;
        }
        if(vec[pos].t>d){
            cout<<"IMPOSSIBLE";
            return 0;
        }
    }
    ll start=0;
    for(int i=0; i<vec.size(); i++){
        ans.pb(mp('r',vec[i].f-start-1));
        if(vec[i].f-start-1>=S){
            start=vec[i].s+1;
            ans.pb(mp('j',vec[i].triple+1));
        }else{
             cout<<"IMPOSSIBLE";
            return 0;
        }
    }**/
       for(int i=0; i<ans.size(); i++){
            if(ans[i].f=='r')
                cout<<"RUN ";
            else
                cout<<"JUMP ";
            cout<<ans[i].s<<endl;
       }
       if(start!=m)
        cout<<"RUN "<<m-start;
        if(ans.empty()){
            cout<<"IMPOSSIBLE";
            return 0;
        }
}


#include<bits/stdc++.h>
#define f first
#define s second
#define t triple
#define mp make_pair
#define pb push_back
#define ll long long
#define sqr(x) (x)*(x)
#define all(a) (a).begin(),(a).end()

using namespace std;

struct tripl{
    ll first,second,triple;
};

tripl make_tripl(ll x, ll y, ll z){
    tripl tr;
    tr.f=x;
    tr.s=y;
    tr.t=z;
    return tr;
}

vector<tripl> vec;
vector<pair<char, ll> > ans;
long long n,m,S,d,x[200001],pos;

bool run(ll pos, ll l){
        if(x[l+1]>=pos && x[l+1]<=pos+S)
            return false;
    return true;
}

ll fnd(ll X){
    for(int i=n-1;i>=0; i--)
         if(x[i]<=X)
             return i;
}

int main(){
    cin>>n>>m>>S>>d;
    for(int i=0; i<n; i++){
        cin>>x[i];
    }
    sort(x,x+n);
    ll start = 0;
    for(int i=0; i<n; i++){
       //cout<<start<<" "<<x[i]<<endl;
       if((x[i]-1-start)<S){
         cout<<"IMPOSSIBLE";
            return 0;
       }
        ans.pb(mp('r',x[i]-1-start));
        start=x[i]-1;
        ll r=fnd(start+d);
        for(int j=r; j>=i; j--){
            if(run(x[j]+1,j)){
                ans.pb(mp('j',x[j]+1-x[i]+1));
                if(x[j]+1-x[i]+1>d){
                    cout<<"IMPOSSIBLE";
                    return 0;
                }
                start=x[j]+1;
                i=j;
                break;
            }else{
            if(j==i){
                cout<<"IMPOSSIBLE";
                    return 0;

            }
            }
        }
    }
        if(ans.empty()){
        cout<<"IMPOSSIBLE";
            return 0;
    }
       for(int i=0; i<ans.size(); i++){
            if(ans[i].f=='r')
                cout<<"RUN ";
            else
                cout<<"JUMP ";
            cout<<ans[i].s;
            if(i<ans.size()-1)
                cout<<endl;
            if(i==ans.size()-1 && start!=m)
                cout<<endl;
       }
       if(start!=m)
        cout<<"RUN "<<m-start;
}


#include<bits/stdc++.h>
#define f first
#define s second
#define t triple
#define mp make_pair
#define pb push_back
#define ll long long
#define sqr(x) (x)*(x)
#define all(a) (a).begin(),(a).end()

using namespace std;

struct tripl{
    ll first,second,triple;
};

tripl make_tripl(ll x, ll y, ll z){
    tripl tr;
    tr.f=x;
    tr.s=y;
    tr.t=z;
    return tr;
}

vector<tripl> vec;
vector<pair<char, ll> > ans;
long long n,m,S,d,x[200001],pos;

bool run(ll pos, ll l){
        if(x[l+1]>=pos && x[l+1]<=pos+S)
            return false;
    return true;
}

ll fnd(ll X){
    for(int i=n-1;i>=0; i++)
         if(x[i]<=X)
             return i;
}

int main(){
    cin>>n>>m>>S>>d;
    for(int i=0; i<n; i++){
        cin>>x[i];
    }
    sort(x,x+n);
    ll start = 0;
    for(int i=0; i<n; i++){
       //cout<<start<<" "<<x[i]<<endl;
       if((x[i]-1-start)<S){
         cout<<"IMPOSSIBLE";
            return 0;
       }
        ans.pb(mp('r',x[i]-1-start));
        start=x[i]-1;
        ll r=fnd(start+d);
        for(int j=r; j>=i; j--){
            if(run(x[j]+1,j)){
                ans.pb(mp('j',x[j]+1-x[i]+1));
                if(x[j]+1-x[i]+1>d){
                    cout<<"IMPOSSIBLE";
                    return 0;
                }
                start=x[j]+1;
                i=j;
                break;
            }else{
            if(j==i){
                cout<<"IMPOSSIBLE";
                    return 0;

            }
            }
        }
    }
        if(ans.empty()){
        cout<<"IMPOSSIBLE";
            return 0;
    }
       for(int i=0; i<ans.size(); i++){
            if(ans[i].f=='r')
                cout<<"RUN ";
            else
                cout<<"JUMP ";
            cout<<ans[i].s;
            if(i<ans.size()-1)
                cout<<endl;
            if(i==ans.size()-1 && start!=m)
                cout<<endl;
       }
       if(start!=m)
        cout<<"RUN "<<m-start;
}


#include<bits/stdc++.h>
#define f first
#define s second
#define t triple
#define mp make_pair
#define pb push_back
#define ll long long
#define sqr(x) (x)*(x)
#define all(a) (a).begin(),(a).end()

using namespace std;

struct tripl{
    ll first,second,triple;
};

tripl make_tripl(ll x, ll y, ll z){
    tripl tr;
    tr.f=x;
    tr.s=y;
    tr.t=z;
    return tr;
}

vector<tripl> vec;
vector<pair<char, ll> > ans;
long long n,m,S,d,x[200001],pos;

bool run(ll pos, ll l){
        if(x[l+1]>=pos && x[l+1]<=pos+S)
            return false;
    return true;
}

ll fnd(ll X){
    ll l=0;
    ll r=n-1;
    while(r-l>1){
        ll mid=(r+l)/2;
        if(x[mid]>X)
            r=mid;
        else l=mid;
    }
    if(x[r]<X)
        return r;
    return l;
}

int main(){
    cin>>n>>m>>S>>d;
    for(int i=0; i<n; i++){
        cin>>x[i];
    }
    sort(x,x+n);
    ll start = 0;
    for(int i=0; i<n; i++){
       //cout<<start<<" "<<x[i]<<endl;
       if((x[i]-1-start)<S){
         cout<<"IMPOSSIBLE";
            return 0;
       }
        ans.pb(mp('r',x[i]-1-start));
        start=x[i]-1;
        ll r=fnd(start+d);
        for(int j=r; j>=i; j--){
            if(run(x[j]+1,j)){
                ans.pb(mp('j',x[j]+1-x[i]+1));
                if(x[j]+1-x[i]+1>d){
                    cout<<"IMPOSSIBLE";
                    return 0;
                }
                start=x[j]+1;
                i=j;
                break;
            }else{
            if(j==i){
                cout<<"IMPOSSIBLE";
                    return 0;

            }
            }
        }
    }
        if(ans.empty()){
        cout<<"IMPOSSIBLE";
            return 0;
    }
       for(int i=0; i<ans.size(); i++){
            if(ans[i].f=='r')
                cout<<"RUN ";
            else
                cout<<"JUMP ";
            cout<<ans[i].s;
            if(i<ans.size()-1)
                cout<<endl;
            if(i==ans.size()-1 && start!=m)
                cout<<endl;
       }
       if(start!=m)
        cout<<"RUN "<<m-start;
}


#include<bits/stdc++.h>
#define f first
#define s second
#define t triple
#define mp make_pair
#define pb push_back
#define ll long long
#define sqr(x) (x)*(x)
#define all(a) (a).begin(),(a).end()

using namespace std;

struct tripl{
    ll first,second,triple;
};

tripl make_tripl(ll x, ll y, ll z){
    tripl tr;
    tr.f=x;
    tr.s=y;
    tr.t=z;
    return tr;
}

vector<tripl> vec;
vector<pair<char, ll> > ans;
long long n,m,S,d,x[200001],pos;

bool run(ll pos, ll l){
        if(x[l+1]>=pos && x[l+1]<=pos+S)
            return false;
    return true;
}

ll fnd(ll X){
    ll l=0;
    ll r=n-1;
    while(r-l>1){
        ll mid=(r+l)/2;
        if(x[mid]>X)
            r=mid;
        else l=mid;
    }
    if(x[r]<X)
        return r;
    return l;
}

int main(){
    cin>>n>>m>>S>>d;
    for(int i=0; i<n; i++){
        cin>>x[i];
    }
    sort(x,x+n);
    ll start = 0;
    for(int i=0; i<n; i++){
       //cout<<start<<" "<<x[i]<<endl;
       if((x[i]-1-start)<S){
         cout<<"IMPOSSIBLE";
            return 0;
       }
        ans.pb(mp('r',x[i]-1-start));
        start=x[i]-1;
        ll r=fnd(start+d);
        for(int j=r; j>=i; j--){
            if(run(x[j]+1,j)){
                ans.pb(mp('j',x[j]+1-x[i]+1));
                if(x[j]+1-x[i]+1>d){
                    cout<<"IMPOSSIBLE";
                    return 0;
                }
                start=x[j]+1;
                i=j;
                break;
            }else{
            if(j==i){
                cout<<"IMPOSSIBLE";
                    return 0;

            }
            }
        }
    }
        if(ans.empty()){
        cout<<"IMPOSSIBLE";
            return 0;
    }
       for(int i=0; i<ans.size(); i++){
            if(ans[i].f=='r')
                cout<<"RUN ";
            else
                cout<<"JUMP ";
            cout<<ans[i].s;
            if(i<ans.size()-1)
                cout<<endl;
       }
       if(start!=m)
        cout<<"RUN "<<m-start;
}


#include<bits/stdc++.h>
#define f first
#define s second
#define t triple
#define mp make_pair
#define pb push_back
#define ll long long
#define sqr(x) (x)*(x)
#define all(a) (a).begin(),(a).end()

using namespace std;

struct tripl{
    ll first,second,triple;
};

tripl make_tripl(ll x, ll y, ll z){
    tripl tr;
    tr.f=x;
    tr.s=y;
    tr.t=z;
    return tr;
}

vector<tripl> vec;
vector<pair<char, ll> > ans;
long long n,m,S,d,x[200001],pos;

bool run(ll pos, ll l){
        if(x[l+1]>=pos && x[l+1]<=pos+S)
            return false;
    return true;
}

ll fnd(ll X){
    for(int i=n-1;i>=0; i--)
         if(x[i]<X)
             return i;
}

int main(){
    cin>>n>>m>>S>>d;
    for(int i=0; i<n; i++){
        cin>>x[i];
    }
    sort(x,x+n);
    ll start = 0;
    for(int i=0; i<n; i++){
       //cout<<start<<" "<<x[i]<<endl;
       if((x[i]-1-start)<S){
         cout<<"IMPOSSIBLE";
            return 0;
       }
        ans.pb(mp('r',x[i]-1-start));
        start=x[i]-1;
        ll r=fnd(start+d);
        for(int j=r; j>=i; j--){
            if(run(x[j]+1,j)){
                ans.pb(mp('j',x[j]+1-x[i]+1));
                if(x[j]+1-x[i]+1>d){
                    cout<<"IMPOSSIBLE";
                    return 0;
                }
                start=x[j]+1;
                i=j;
                break;
            }else{
            if(j==i){
                cout<<"IMPOSSIBLE";
                    return 0;

            }
            }
        }
    }
        if(ans.empty()){
        cout<<"IMPOSSIBLE";
            return 0;
    }
       for(int i=0; i<ans.size(); i++){
            if(ans[i].f=='r')
                cout<<"RUN ";
            else
                cout<<"JUMP ";
            cout<<ans[i].s;
            if(i<ans.size()-1)
                cout<<endl;
            if(i==ans.size()-1 && start!=m)
                cout<<endl;
       }
       if(start!=m)
        cout<<"RUN "<<m-start;
}


#include<bits/stdc++.h>
#define f first
#define s second
#define t triple
#define mp make_pair
#define pb push_back
#define ll long long
#define sqr(x) (x)*(x)
#define all(a) (a).begin(),(a).end()

using namespace std;

struct tripl{
    ll first,second,triple;
};

tripl make_tripl(ll x, ll y, ll z){
    tripl tr;
    tr.f=x;
    tr.s=y;
    tr.t=z;
    return tr;
}

vector<tripl> vec;
vector<pair<char, ll> > ans;
long long n,m,S,d,x[200001],pos;

bool run(ll pos, ll l){
        if(x[l+1]>=pos && x[l+1]<=pos+S)
            return false;
    return true;
}

ll fnd(ll X){
    for(int i=n-1;i>=0; i--)
         if(x[i]<X && run(x[i]+1))
             return i;
}

int main(){
    cin>>n>>m>>S>>d;
    for(int i=0; i<n; i++){
        cin>>x[i];
    }
    sort(x,x+n);
    ll start = 0;
    for(int i=0; i<n; i++){
       //cout<<start<<" "<<x[i]<<endl;
       if((x[i]-1-start)<S){
         cout<<"IMPOSSIBLE";
            return 0;
       }
        ans.pb(mp('r',x[i]-1-start));
        start=x[i]-1;
        ll r=fnd(start+d);
        for(int j=r; j>=i; j--){
            if(run(x[j]+1,j)){
                ans.pb(mp('j',x[j]+1-x[i]+1));
                if(x[j]+1-x[i]+1>d){
                    cout<<"IMPOSSIBLE";
                    return 0;
                }
                start=x[j]+1;
                i=j;
                break;
            }else{
            if(j==i){
                cout<<"IMPOSSIBLE";
                    return 0;

            }
            }
        }
    }
        if(ans.empty()){
        cout<<"IMPOSSIBLE";
            return 0;
    }
       for(int i=0; i<ans.size(); i++){
            if(ans[i].f=='r')
                cout<<"RUN ";
            else
                cout<<"JUMP ";
            cout<<ans[i].s;
            if(i<ans.size()-1)
                cout<<endl;
            if(i==ans.size()-1 && start!=m)
                cout<<endl;
       }
       if(start!=m)
        cout<<"RUN "<<m-start;
}


#include<bits/stdc++.h>
#define f first
#define s second
#define t triple
#define mp make_pair
#define pb push_back
#define ll long long
#define sqr(x) (x)*(x)
#define all(a) (a).begin(),(a).end()

using namespace std;

struct tripl{
    ll first,second,triple;
};

tripl make_tripl(ll x, ll y, ll z){
    tripl tr;
    tr.f=x;
    tr.s=y;
    tr.t=z;
    return tr;
}

vector<tripl> vec;
vector<pair<char, ll> > ans;
long long n,m,S,d,x,pos;

int main(){
    cin>>n>>m>>S>>d;
    for(int i=0; i<n; i++){
        cin>>x;
        if(vec.empty()){
            vec.pb(make_tripl(x,x,1));
            continue;
        }
        if(vec[pos].s+1==x){
            vec[pos].s=x;
            vec[pos].t++;
        }else{
            vec.pb(make_tripl(x,x,1));
            pos++;
        }
        if(vec[pos].t>d){
            cout<<"IMPOSSIBLE";
            return 0;
        }
    }
    ll start=0;
    for(int i=0; i<vec.size(); i++){
        ans.pb(mp('r',vec[i].f-start-1));
        if(vec[i].f-start-1>=S){
            start=vec[i].s;
            ans.pb(mp('j',vec[i].triple));
        }else{
             cout<<"IMPOSSIBLE";
            return 0;
        }
    }
       for(int i=0; i<ans.size(); i++){
            if(ans[i].f=='r')
                cout<<"RUN ";
            else
                cout<<"JUMP ";
            cout<<ans[i].s<<endl;
       }
       if(start!=m)
        cout<<"RUN "<<m-start;
}


#include<bits/stdc++.h>
#define f first
#define s second
#define t triple
#define mp make_pair
#define pb push_back
#define ll long long
#define sqr(x) (x)*(x)
#define all(a) (a).begin(),(a).end()

using namespace std;

struct tripl{
    ll first,second,triple;
};

tripl make_tripl(ll x, ll y, ll z){
    tripl tr;
    tr.f=x;
    tr.s=y;
    tr.t=z;
    return tr;
}

vector<tripl> vec;
vector<pair<char, ll> > ans;
long long n,m,S,d,x[200001],pos;

bool run(ll pos, ll l){
        if(x[l+1]>=pos && x[l+1]<=pos+S)
            return false;
    return true;
}

ll fnd(ll X, int l){
    for(int i=n-1;i>=l; i--)
         if(x[i]<X)
             return i;
    return l;
}

int main(){
    cin>>n>>m>>S>>d;
    for(int i=0; i<n; i++){
        cin>>x[i];
    }
    sort(x,x+n);
    ll start = 0;
    for(int i=0; i<n; i++){
       //cout<<start<<" "<<x[i]<<endl;
       if((x[i]-1-start)<S){
         cout<<"IMPOSSIBLE";
            return 0;
       }
        ans.pb(mp('r',x[i]-1-start));
        start=x[i]-1;
        ll r=fnd(start+d,i);
        for(int j=r; j>=i; j--){
            if(run(x[j]+1,j)){
                ans.pb(mp('j',x[j]+1-x[i]+1));
                if(x[j]+1-x[i]+1>d){
                    cout<<"IMPOSSIBLE";
                    return 0;
                }
                start=x[j]+1;
                i=j;
                break;
            }else{
            if(j==i){
                cout<<"IMPOSSIBLE";
                    return 0;

            }
            }
        }
    }
        if(ans.empty()){
        cout<<"IMPOSSIBLE";
            return 0;
    }
       for(int i=0; i<ans.size(); i++){
            if(ans[i].f=='r')
                cout<<"RUN ";
            else
                cout<<"JUMP ";
            cout<<ans[i].s;
            if(i<ans.size()-1)
                cout<<endl;
            if(i==ans.size()-1 && start!=m)
                cout<<endl;
       }
       if(start!=m)
        cout<<"RUN "<<m-start;
}


#include<bits/stdc++.h>
#define f first
#define s second
#define t triple
#define mp make_pair
#define pb push_back
#define ll long long
#define sqr(x) (x)*(x)
#define all(a) (a).begin(),(a).end()

using namespace std;

struct tripl{
    ll first,second,triple;
};

tripl make_tripl(ll x, ll y, ll z){
    tripl tr;
    tr.f=x;
    tr.s=y;
    tr.t=z;
    return tr;
}

vector<tripl> vec;
vector<pair<char, ll> > ans;
long long n,m,S,d,x[200001],pos;

int main(){
    cin>>n>>m>>S>>d;
    for(int i=0; i<n; i++){
        cin>>x[i];
    }
    sort(x,x+n);
    for(int i=0; i<n; i++){
        if(vec.empty()){
            vec.pb(make_tripl(x[i],x[i],1));
            continue;
        }
        if(vec[pos].s+1==x[i]){
            vec[pos].s=x[i];
            vec[pos].t++;
        }else{
            vec.pb(make_tripl(x[i],x[i],1));
            pos++;
        }
        if(vec[pos].t>d){
            cout<<"IMPOSSIBLE";
            return 0;
        }
    }
    ll start=0;
    for(int i=0; i<vec.size(); i++){
        ans.pb(mp('r',vec[i].f-start-1));
        if(vec[i].f-start-1>=S){
            start=vec[i].s+1;
            ans.pb(mp('j',vec[i].triple+1));
        }else{
             cout<<"IMPOSSIBLE";
            return 0;
        }
    }
       for(int i=0; i<ans.size(); i++){
            if(ans[i].f=='r')
                cout<<"RUN ";
            else
                cout<<"JUMP ";
            cout<<ans[i].s<<endl;
       }
       if(start!=m)
        cout<<"RUN "<<m-start;
}


#include<bits/stdc++.h>
#define f first
#define s second
#define t triple
#define mp make_pair
#define pb push_back
#define ll long long

using namespace std;

ll n,m,S,d,x[300001];

vector<pair<char, ll> > ans;

bool run(ll pos, ll l){
    if(x[l+1]>=pos && x[l+1]<=pos+S)
        return false;
    return true;
}

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin>>n>>m>>S>>d;
    for(int i=0; i<n; i++)
        cin>>x[i];
    sort(x,x+n);
    ll start=0;
    for(int i=0; i<n; i++){
        ans.pb(mp('r',x[i]-1-start));
        if(x[i]-1-start<S){
                    cout<<"IMPOSSIBLE";
                    return 0;
        }
        start=x[i]-1;
        for(int j=i; j<n; j++){
            if(run(x[j]+1,j)){
                if(x[j]+1-start>d){
                    cout<<"IMPOSSIBLE";
                    return 0;
                }
                ans.pb(mp('j',x[j]+1-start));
                start=x[j]+1;
                i=j;
                break;
            }else{
                if(j==n-1){
                    cout<<"IMPOSSIBLE";
                    return 0;
                }
            }
        }
    }
    if(ans.empty()){
        cout<<"IMPOSSIBLE";
        return 0;
    }
    for(int i=0; i<ans.size(); i++){
        if(ans[i].f=='r')
            cout<<"RUN ";
        else
            cout<<"JUMP ";
        cout<<ans[i].s<<endl;
    }
    if(start!=m)
        cout<<"RUN "<<m-start;
}


#include<bits/stdc++.h>
#define f first
#define s second
#define t triple
#define mp make_pair
#define pb push_back
#define ll long long
#define sqr(x) (x)*(x)
#define all(a) (a).begin(),(a).end()

using namespace std;

struct tripl{
    ll first,second,triple;
};

tripl make_tripl(ll x, ll y, ll z){
    tripl tr;
    tr.f=x;
    tr.s=y;
    tr.t=z;
    return tr;
}

vector<tripl> vec;
vector<pair<char, ll> > ans;
long long n,m,S,d,x,pos;

int main(){
    cin>>n>>m>>S>>d;
    for(int i=0; i<n; i++){
        cin>>x;
        if(vec.empty()){
            vec.pb(make_tripl(x,x,1));
            continue;
        }
        if(vec[pos].s+1==x){
            vec[pos].s=x;
            vec[pos].t++;
        }else{
            vec.pb(make_tripl(x,x,1));
            pos++;
        }
        if(vec[pos].t>d){
            cout<<"IMPOSSIBLE";
            return 0;
        }
    }
    ll start=0;
    for(int i=0; i<vec.size(); i++){
        ans.pb(mp('r',vec[i].f-start-1));
        if(vec[i].f-start-1>=S){
            start=vec[i].s+1;
            ans.pb(mp('j',vec[i].triple+1));
        }else{
             cout<<"IMPOSSIBLE";
            return 0;
        }
    }
       for(int i=0; i<ans.size(); i++){
            if(ans[i].f=='r')
                cout<<"RUN ";
            else
                cout<<"JUMP ";
            cout<<ans[i].s<<endl;
       }
       if(start!=m)
        cout<<"RUN "<<m-start;
}


#include <bits/stdc++.h>

#define ll long long
#define ull unsigned long long
#define ld long double
#define sz size()
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define fs first
#define sc second

using namespace std;

int main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	int n, m, s, d;
	cin >> n >> m >> s >> d;
	vector<vector<int> > a;
	vector<int> v;
	a.pb(v);
	vector<int> b(n);
	for (int i = 0; i<n; i++)
		cin >> b[i];
	sort(all(b));
	for (int i = 0; i<n; i++) {
		int x = b[i];
		if (a[i].empty() || x - a[a.size() - 1].back() - 2 < s) {
			a[a.size() - 1].pb(x);
		} else {
			vector<int> v;
			v.pb(x);
			a.pb(v);
		}
	}
	/*for (int i = 0; i<a.size(); i++) {
		for (int j = 0; j<a[i].size(); j++)
			cout << a[i][j] << " ";
		cout << "\n";
	}*/
	vector<pair<string, int> > ans;
	int cur = 0;
	int t = a.size();
	for (int i = 0; i<t; i++) {
		int fr = a[i][0], to = a[i].back();
		ans.pb(mp("RUN", fr - cur - 1));
		if (fr - cur - 1 < s) {
			cout << "IMPOSSIBLE\n";
			return 0;
		}
		ans.pb(mp("JUMP", to - fr + 2));
		cur = to + 1;
		if (to - fr + 2 > d) {
			cout << "IMPOSSIBLE\n";
			return 0;
		}
	}

	ans.pb(mp("RUN", m - cur));
	for (int i = 0; i<ans.size(); i++)
		if (!(ans[i].fs == "RUN" && ans[i].sc == 0))
			cout << ans[i].fs << " " << ans[i].sc << " " << "\n";
	return 0;
}


#include <bits/stdc++.h>

#define ll long long
#define ull unsigned long long
#define ld long double
#define sz size()
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define fs first
#define sc second

using namespace std;

int main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	int n, m, s, d;
	cin >> n >> m >> s >> d;
	vector<vector<int> > a;
	vector<int> v;
	a.pb(v);
	vector<int> b(n);
	for (int i = 0; i<n; i++)
		cin >> b[i];
	sort(all(b));
	for (int i = 0; i<n; i++) {
		int x = b[i];
		if (a[i].empty() || x - a[a.size() - 1].back() <= s) {
			a[a.size() - 1].pb(x);
		} else {
			vector<int> v;
			v.pb(x);
			a.pb(v);
		}
	}
	/*for (int i = 0; i<a.size(); i++) {
		for (int j = 0; j<a[i].size(); j++)
			cout << a[i][j] << " ";
		cout << "\n";
	}*/
	vector<pair<string, int> > ans;
	int cur = 0;
	int t = a.size();
	for (int i = 0; i<t; i++) {
		int fr = a[i][0], to = a[i].back();
		ans.pb(mp("RUN", fr - cur - 1));
		ans.pb(mp("JUMP", to - fr + 2));
		cur = to + 1;
		if (to - fr + 2 > d) {
			cout << "IMPOSSIBLE\n";
			return 0;
		}
	}
	ans.pb(mp("RUN", m - cur));
	for (int i = 0; i<ans.size(); i++)
		if (!(ans[i].fs == "RUN" && ans[i].sc == 0))
			cout << ans[i].fs << " " << ans[i].sc << " " << "\n";
	return 0;
}


#include <bits/stdc++.h>

#define ll long long
#define ull unsigned long long
#define ld long double
#define sz size()
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define fs first
#define sc second

using namespace std;

int main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	int n, m, s, d;
	cin >> n >> m >> s >> d;
	vector<vector<int> > a;
	vector<int> v;
	a.pb(v);
	vector<int> b(n);
	for (int i = 0; i<n; i++)
		cin >> b[i];
	sort(all(b));
	for (int i = 0; i<n; i++) {
		int x = b[i];
		if (a[i].empty() || x - a[a.size() - 1].back() - 2 < s) {
			a[a.size() - 1].pb(x);
		} else {
			vector<int> v;
			v.pb(x);
			a.pb(v);
		}
	}
	/*for (int i = 0; i<a.size(); i++) {
		for (int j = 0; j<a[i].size(); j++)
			cout << a[i][j] << " ";
		cout << "\n";
	}*/
	vector<pair<string, int> > ans;
	int cur = 0;
	int t = a.size();
	for (int i = 0; i<t; i++) {
		int fr = a[i][0], to = a[i].back();
		ans.pb(mp("RUN", fr - cur - 1));
		ans.pb(mp("JUMP", to - fr + 2));
		cur = to + 1;
		if (to - fr + 2 > d) {
			cout << "IMPOSSIBLE\n";
			return 0;
		}
	}

	ans.pb(mp("RUN", m - cur));
	for (int i = 0; i<ans.size(); i++)
		if (!(ans[i].fs == "RUN" && ans[i].sc == 0))
			cout << ans[i].fs << " " << ans[i].sc << " " << "\n";
	return 0;
}


#include <bits/stdc++.h>

#define ll long long
#define ull unsigned long long
#define ld long double
#define sz size()
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define fs first
#define sc second

using namespace std;

int main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	int n, m, s, d;
	cin >> n >> m >> s >> d;
	vector<vector<int> > a;
	vector<int> v;
	a.pb(v);
	vector<int> b(n);
	for (int i = 0; i<n; i++)
		cin >> b[i];
	sort(all(b));
	for (int i = 0; i<n; i++) {
		int x = b[i];
		if ((a[a.size() - 1].empty()) || ((x - a[a.size() - 1].back() - 2) < s)) {
			a[a.size() - 1].pb(x);
		} else {
			vector<int> v;
			v.pb(x);
			a.pb(v);
		}
	}
	vector<pair<string, int> > ans;
	int cur = 0;
	int t = a.size();
	for (int i = 0; i<t; i++) {
		int fr = a[i][0], to = a[i].back();
		ans.pb(mp("RUN", fr - cur - 1));
		if (fr - cur - 1 < s) {
			cout << "IMPOSSIBLE\n";
			return 0;
		}
		ans.pb(mp("JUMP", to - fr + 2));
		cur = to + 1;
		if (to - fr + 2 > d) {
			cout << "IMPOSSIBLE\n";
			return 0;
		}
	}

	ans.pb(mp("RUN", m - cur));
	for (int i = 0; i<ans.size(); i++)
		if (!(ans[i].fs == "RUN" && ans[i].sc == 0))
			cout << ans[i].fs << " " << ans[i].sc << " " << "\n";
	return 0;
}


#include <bits/stdc++.h>

using namespace std;
const int INF = 1e9 + 1e9;
int n, m, s, d, a[200005];
string ans[2000005];
int ans1[2000005];
int main() {
	#ifdef LOCAL
		freopen("test.in", "r", stdin);
		freopen("test.out", "w", stdout);
	#endif
	cin >> n >> m >> s >> d;

	for(int i = 0; i < n; i++)
		cin >> a[i];

	a[n] = INF;
	sort(a, a + n);

	int curx = 0, cnt = 0;
	for(int i = 0; i < n; i++) {
		if(a[i] - 1 - curx < s)
			return !printf("IMPOSSIBLE");

		ans[cnt] = "RUN";
		ans1[cnt++] = a[i] - 1 - curx;
		curx = a[i] - 1;

	    //cerr << curx << " ";
		ans[cnt] = "JUMP";

		int next = a[i] + 1;
		while(a[i + 1] - a[i] - 2 < s)
			next = a[i + 1] + 1, i++;

		//cerr << next << " ";
		if(curx + d >= next) {
			ans1[cnt++] = next - curx;
			curx = next;
		} else
			return !printf("IMPOSSIBLE");
		//cerr << curx << "\n";
	}
	ans[cnt] = "RUN";
	ans1[cnt++] = m - curx;

	for(int i = 0; i < cnt; i++)
		if(ans1[i])
			cout << ans[i] << " " << ans1[i] << "\n";
	return 0;
}


#include <bits/stdc++.h>

using namespace std;
const int INF = 1e9 + 7;
int n, m, s, d, a[200005];
string ans[2000005];
int ans1[2000005];
int main() {
	#ifdef LOCAL
		freopen("test.in", "r", stdin);
		freopen("test.out", "w", stdout);
	#endif
	cin >> n >> m >> s >> d;

	for(int i = 0; i < n; i++)
		cin >> a[i];

	a[n] = m + 1;
	sort(a, a + n);

	int curx = 0, cnt = 0;
	while(curx < m) {
		int nr = *lower_bound(a, a + n, curx) - 1;
		if(nr - curx >= s) {
			ans[cnt] = "RUN";
			ans1[cnt++] = nr - curx;
			curx = nr;
			if(curx == m)
				break;
			ans[cnt] = "JUMP";
			int next = (int)(upper_bound(a, a + n, curx + d - 1) - a);
			next--;
			if(a[next + 1] != a[next] + 1) {
				ans1[cnt++] = a[next] + 1 - curx;
				curx = a[next] + 1;
			} else {
				next--;
				ans1[cnt++] = a[next] + 1 - curx;
				curx = a[next] + 1;
			}
			//cerr << curx << "\n";
		} else {
			return !printf("IMPOSSIBLE");
		}
	}
	for(int i = 0; i < cnt; i++)
		if(ans1[i])
			cout << ans[i] << " " << ans1[i] << "\n";
	return 0;
}


#include <bits/stdc++.h>

using namespace std;
const int INF = 1e9 + 7;
int n, m, s, d, a[200005];
string ans[2000005];
int ans1[2000005];
int main() {
	#ifdef LOCAL
		freopen("test.in", "r", stdin);
		freopen("test.out", "w", stdout);
	#endif
	cin >> n >> m >> s >> d;

	for(int i = 0; i < n; i++)
		cin >> a[i];

	a[n] = m + 1;
	sort(a, a + n);

	int curx = 0, cnt = 0;
	for(int i = 0; i < n; i++) {
		if(a[i] - 1 - curx < s)
			return !printf("IMPOSSIBLE");

		ans[cnt] = "RUN";
		ans1[cnt++] = a[i] - 1 - curx;
		curx = a[i] - 1;

	    //cerr << curx << " ";
		ans[cnt] = "JUMP";

		int next = a[i] + 1;
		while(a[i + 1] == a[i] + 1)
			next++, i++;

		if(curx + d >= next) {
			ans1[cnt++] = next - curx;
			curx = next;
		} else
			return !printf("IMPOSSIBLE");
		//cerr << curx << "\n";
	}
	ans[cnt] = "RUN";
	ans1[cnt++] = m - a[n - 1] - 1;

	for(int i = 0; i < cnt; i++)
		if(ans1[i])
			cout << ans[i] << " " << ans1[i] << "\n";
	return 0;
}


#include <bits/stdc++.h>

using namespace std;
const int INF = 1e9 + 7;
int n, m, s, d, a[200005];
string ans[2000005];
int ans1[2000005];
int main() {
	#ifdef LOCAL
		freopen("test.in", "r", stdin);
		freopen("test.out", "w", stdout);
	#endif
	cin >> n >> m >> s >> d;

	for(int i = 0; i < n; i++)
		cin >> a[i];

	a[n] = m + 1;
	sort(a, a + n);

	int curx = 0, cnt = 0;
	for(int i = 0; i < n; i++) {
		if(a[i] - 1 - curx < s)
			return !printf("IMPOSSIBLE");

		ans[cnt] = "RUN";
		ans1[cnt++] = a[i] - 1 - curx;
		curx = a[i] - 1;

	    //cerr << curx << " ";
		ans[cnt] = "JUMP";

		int next = a[i] + 1;
		while(a[i + 1] == a[i] + 1)
			next++, i++;

		if(curx + d >= next) {
			ans1[cnt++] = next - curx;
			curx = next;
		} else
			return !printf("IMPOSSIBLE");
		//cerr << curx << "\n";
	}
	ans[cnt] = "RUN";
	ans1[cnt++] = m - curx;

	for(int i = 0; i < cnt; i++)
		if(ans1[i])
			cout << ans[i] << " " << ans1[i] << "\n";
	return 0;
}


#include <bits/stdc++.h>
#define sz(x) (int((x).size()))
#define pb push_back
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
template<typename T> bool domax(T &a, T b) { return (b > a ? (a = b, true) : false); }
template<typename T> bool domin(T &a, T b) { return (b < a ? (a = b, true) : false); }
typedef long long ll;

const int maxn = 200*1000+5;

int n, m, s, d, a[maxn], prev[maxn];
std::deque<int> jumps, idx;
std::vector<std::pair<int, int>> v;

void addjump(int a, int b) { v.eb(0, b-a); }
void addrun(int a, int b) { v.eb(1, b-a); }

int main() {
    scanf("%d%d%d%d", &n, &m, &s, &d);
    for (int i = 0; i < n; i++) scanf("%d", &a[i]);
    std::sort(a, a+n);
    for (int i = 0; i < n; i++) {
        if (i == 0) {
            if (a[i]-1 >= s) {
                jumps.pb(a[i]-1+d);
                idx.pb(i);
            }
        } else {
            if (!jumps.empty() && a[i]-1 - (a[i-1]+1)) {
                jumps.pb(a[i]-1+d);
                idx.pb(i);
                prev[i] = idx.front();
            }
            while (!jumps.empty() && jumps.front() <= a[i]) {
                jumps.pop_front();
                idx.pop_front();
            }
        }
    }
    if (d == 1 || jumps.empty()) printf("IMPOSSIBLE\n");
    else {
        int cur = idx.front();
        addrun(a[n-1]+1, m);
        addjump(a[cur]-1, a[n-1]+1);
        while (cur) {
            addrun(a[cur-1]+1, a[cur]-1);
            addjump(a[prev[cur]]-1, a[cur-1]+1);
            cur = prev[cur];
        }
        addrun(0, a[0]-1);
        std::reverse(all(v));
        for (auto &pair : v) {
            printf("%s %d\n", pair.first ? "RUN" : "JUMP", pair.second);
        }
    }
}


#include <bits/stdc++.h>
#define sz(x) (int((x).size()))
#define pb push_back
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
template<typename T> bool domax(T &a, T b) { return (b > a ? (a = b, true) : false); }
template<typename T> bool domin(T &a, T b) { return (b < a ? (a = b, true) : false); }
typedef long long ll;

const int maxn = 200*1000+5;

int n, m, s, d, a[maxn], prev[maxn];
std::deque<int> jumps, idx;
std::vector<std::pair<int, int>> v;

void addjump(int a, int b) { v.eb(0, b-a); }
void addrun(int a, int b) { v.eb(1, b-a); }

int main() {
    scanf("%d%d%d%d", &n, &m, &s, &d);
    for (int i = 0; i < n; i++) scanf("%d", &a[i]);
    std::sort(a, a+n);
    for (int i = 0; i < n; i++) {
        if (i == 0) {
            if (a[i]-1 >= s) {
                jumps.pb(a[i]-1+d);
                idx.pb(i);
            }
        } else {
            if (!jumps.empty() && a[i]-1 - (a[i-1]+1) >= s) {
                jumps.pb(a[i]-1+d);
                idx.pb(i);
                prev[i] = idx.front();
            }
            while (!jumps.empty() && jumps.front() <= a[i]) {
                jumps.pop_front();
                idx.pop_front();
            }
        }
    }
    if (d == 1 || jumps.empty()) printf("IMPOSSIBLE\n");
    else {
        int cur = idx.front();
        addrun(a[n-1]+1, m);
        addjump(a[cur]-1, a[n-1]+1);
        while (cur) {
            addrun(a[cur-1]+1, a[cur]-1);
            addjump(a[prev[cur]]-1, a[cur-1]+1);
            cur = prev[cur];
        }
        addrun(0, a[0]-1);
        std::reverse(all(v));
        for (auto &pair : v) {
            printf("%s %d\n", pair.first ? "RUN" : "JUMP", pair.second);
        }
    }
}


#include <bits/stdc++.h>
#define sz(x) (int((x).size()))
#define pb push_back
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
template<typename T> bool domax(T &a, T b) { return (b > a ? (a = b, true) : false); }
template<typename T> bool domin(T &a, T b) { return (b < a ? (a = b, true) : false); }
typedef long long ll;

const int maxn = 200*1000+5;

int n, m, s, d, a[maxn], prev[maxn];
std::deque<int> jumps, idx;
std::vector<std::pair<int, int>> v;

void addjump(int a, int b) { v.eb(0, b-a); }
void addrun(int a, int b) { v.eb(1, b-a); }

int main() {
    scanf("%d%d%d%d", &n, &m, &s, &d);
    for (int i = 0; i < n; i++) scanf("%d", &a[i]);
    std::sort(a, a+n);
    for (int i = 0; i < n; i++) {
        if (i == 0) {
            if (a[i]-1 >= s) {
                jumps.pb(a[i]-1+d);
                idx.pb(i);
            }
        } else {
            if (!jumps.empty() && a[i]-1 - (a[i-1]+1) >= s) {
                jumps.pb(a[i]-1+d);
                idx.pb(i);
                prev[i] = idx.front();
            }
            while (!jumps.empty() && jumps.front() <= a[i]) {
                jumps.pop_front();
                idx.pop_front();
            }
        }
    }
    if (d == 1 || jumps.empty()) printf("IMPOSSIBLE\n");
    else {
        int cur = idx.front();
        addrun(a[n-1]+1, m);
        addjump(a[cur]-1, a[n-1]+1);
        while (cur) {
            addrun(a[cur-1]+1, a[cur]-1);
            addjump(a[prev[cur]]-1, a[cur-1]+1);
            cur = prev[cur];
        }
        addrun(0, a[0]-1);
        std::reverse(all(v));
        for (auto &pair : v) {
            if (pair.second) printf("%s %d\n", pair.first ? "RUN" : "JUMP", pair.second);
        }
    }
}