#include <cstdio>
#include <cstring>
#include <algorithm>
#include <numeric>
#include <vector>
#include <queue>
#include <map>
#include <cmath>
#include <cctype>
#include <set>
#include <random>
#include <bitset>

namespace uvu
{
#define LOCAL ____________DONT_DEFINE_ME____________
#define ll long long
#define inf 0x3f3f3f3f
// #define int long long
// #define inf 0x3f3f3f3f3f3f3f3fll
#define infll 0x3f3f3f3f3f3f3f3fll
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define gline debug("now is #%d\n", __LINE__)
#define pii std::pair <int, int>
#define mkp std::make_pair
#define fi first
#define se second
char _ST_;
const int BUFSIZE = (1 << 20);
char ibuf[BUFSIZE], *iS = ibuf, *iT = ibuf;
char obuf[BUFSIZE], *oS = obuf, *oT = obuf + BUFSIZE;
char getc()
{
#ifdef LOCAL
	return getchar();
#else
	if(iS == iT) iT = (iS = ibuf) + fread(ibuf, 1, BUFSIZE, stdin);
	return iS == iT ? EOF : *iS++;
#endif
#define getchar ERR
}

void Flush() { fwrite(obuf, 1, oS - obuf, stdout); oS = obuf; }
struct Flusher { ~Flusher(){ Flush(); } }iamflusher;

void putc(char c)
{
#ifdef LOCAL
	putchar(c);
#else
	*oS++ = c;
	if(oS == oT) Flush();
#endif
#define putchar ERR
}

template <typename T = int> T read()
{
	T x = 0, f = 1; char c = getc();
	for(; !isdigit(c); c = getc()) if(c == '-') f = -1;
	for(;  isdigit(c); c = getc()) x = (x << 3) + (x << 1) + (c ^ 48);
	return x * f;
}

template <typename T> void print(T x, char c)
{
static int sta[BUFSIZE], top;
	top = 0;
	if(x < 0) putc('-'), x = -x;
	if(!x) sta[top = 1] = 0;
	for(; x; x /= 10) sta[++top] = x % 10;
	for(; top; ) putc(sta[top--] ^ 48);
	if(c) putc(c);
}

int readstr(char *s, int base)
{
	int idx = base - 1; char c = getc();
	for(; !(isdigit(c) || isalpha(c) || c == '#' || c == '.'); c = getc());
	for(;   isdigit(c) || isalpha(c) || c == '#' || c == '.' ; c = getc()) s[++idx] = c;
	return idx - base + 1;
}

void printf(const char *s) { for(; *s; s++) putc(*s); }
template <typename T, typename ... Args>
void printf(const char *s, T x, Args ... rest)
{
	for(; *s; s++)
	{
		if(*s != '%') { putc(*s); continue; }
		s++; if(*s == 'd') print(x, 0);
		else if(*s == 'c') putc(x);
		printf(s + 1, rest ...);
		return;
	}
}

template <typename T> void ckmax(T &x, T y) { x = x > y ? x : y; }
template <typename T> void ckmin(T &x, T y) { x = x < y ? x : y; }
#define mod 998244353
// #define mod 1000000007
int sm(int x) { return x >= mod ? x - mod : x; }
void plus_(int &x, int y) { x = (x + y >= mod ? x + y - mod : x + y); }
void mul_(int &x, int y) { x = 1ll * x * y % mod; }
int ksm(int a, int b) { int res = 1; for(; b; b >>= 1, mul_(a, a)) if(b & 1) mul_(res, a); return res; }
int gcd(int x, int y) { for(; y; x %= y, x ^= y ^= x ^= y); return x; }

/*
偏移量必须是整数，这是最强的一个条件。本质上是你无法用 eps 瞎搞了。

能凑出 m 是有解的一个必要条件。一个很脑筋急转弯的事情：若不使用 len=1 就能凑出 m，那直接对随意一种方案让偏移量 =0/1 即可。

否则的话，考虑让 len=1 代替 eps 的地位，看看有什么性质回来了。

“凑出m”这个问题变得没意义了，尝试找一个更严格的条件

上下两行不会产生包含关系，因为可以把小的那行全换成1

这样的话 >1 的段肯定是上下交错的，中间夹杂这一些1，但是你发现对于每次交替，小的那行依然没啥意义，可以删掉一些 1 换成大的那行。

这就代表上下两行 >1 的段是可以一一对应的，每个长度 len 都可以凑出 +[len, 2len-2]。就和上面的判定一样了。

形式像一个同余最短路，但是这个只能 O(n^2 log)。

多项式 exp 显然可以草，怎么构造方案？

min < sqrt 直接同余最短路。
min > sqrt 只会跳 sqrt 次
不会这个啊，还是分治NTT吧。

*/

#define N 300010
int n, m;
int a[N];
int from[N], S;
std::set <int> s;

namespace Sub1
{
ll dis[N];
int lst[N];
bool vis[N];
std::vector <int> vec;
void solve()
{
	memset(dis, 0x3f, sizeof(dis));
	dis[0] = 0;
	for(int i = S + 1; i <= m; i++) if(from[i]) vec.push_back(i);
	for(;;)
	{
		int k = -1;
		for(int i = 0; i < S; i++) if(!vis[i] && (!~k || dis[i] < dis[k])) k = i;
		if(!~k || dis[k] == infll) break;
		vis[k] = 1;
		for(int x : vec) if(dis[(k + x) % S] > dis[k] + x) dis[(k + x) % S] = dis[k] + x, lst[(k + x) % S] = x;
	}
	if(dis[m % S] > m) return printf("impossible\n");
	std::vector <int> v[2];
	int now = m;
	auto push = [&](int x) -> void
	{
		now -= x;
		v[0].push_back(from[x]);
		for(int i = from[x] + 1; i <= x; i++) v[0].push_back(1), v[1].push_back(1);
		v[1].push_back(from[x]);
	};
	while(now)
	{
		if(now != dis[now % S]) push(S);
		else push(lst[now % S]);
	}
	printf("possible\n");
	for(int _ = 0; _ < 2; _++)
	{
		printf("%d %d\n", v[_].size(), _);
		for(int x : v[_]) print(x, ' ');
		putc('\n');
	}
}
} // namespace Sub1

namespace Sub2
{
#define M 1100010
const int G = 3;
const int invG = ksm(G, mod - 2);
int len, tr[M];
void NTT(int *f, int n, int *tr, int op)
{
	for(int i = 0; i < n; i++) if(i < tr[i]) std::swap(f[i], f[tr[i]]);
	for(int p = 2; p <= n; p <<= 1) 
		for(int len = p >> 1, buf = ksm(op ? G : invG, (mod - 1) / p), k = 0; k < n; k += p)
			for(int i = k, tg = 1, tmp; i < k + len; i++, mul_(tg, buf))
				tmp = 1ll * tg * f[i + len] % mod, f[i + len] = sm(f[i] + mod - tmp), plus_(f[i], tmp);
	if(op) { for(int i = 0, invn = ksm(n, mod - 2); i < n; i++) mul_(f[i], invn); }
}

int fNTT[50][M], gNTT[50][M];
void divide1(int n, int dep)
{
	// printf("divide %d %d\n", n, dep);
	if(n == 1) { for(int i = 0; i < len; i++) fNTT[dep][i] = fNTT[0][i], gNTT[dep][i] = gNTT[0][i]; return; }
	if(n & 1)
	{
		divide1(n - 1, dep + 1);
		for(int i = 0; i < len; i++) fNTT[dep][i] = gNTT[dep][i] = 1ll * gNTT[dep + 1][i] * gNTT[0][i] % mod;
		NTT(fNTT[dep], len, tr, 1);
	}
	else
	{
		divide1(n / 2, dep + 1);
		for(int i = 0; i < len; i++) fNTT[dep][i] = gNTT[dep][i] = 1ll * gNTT[dep + 1][i] * gNTT[dep + 1][i] % mod;
		NTT(fNTT[dep], len, tr, 1);
	}
	for(int i = 0; i <= m; i++) gNTT[dep][i] = fNTT[dep][i] = !!fNTT[dep][i];
	for(int i = m + 1; i < len; i++) gNTT[dep][i] = fNTT[dep][i] = 0;
	NTT(gNTT[dep], len, tr, 0);
}

std::vector <int> v[2];

void push(int x)
{
	v[0].push_back(from[x]);
	for(int i = from[x] + 1; i <= x; i++) v[0].push_back(1), v[1].push_back(1);
	v[1].push_back(from[x]);
}

void divide2(int n, int dep, int m)
{
	if(!m) return;
	if(n == 1) { push(m); return; }
	if(n & 1)
	{
		int p = 0;
		while(p <= m && (!fNTT[0][p] || !fNTT[dep + 1][m - p])) p++;
		if(p > m)
		{
			printf("n = %d, dep = %d, m = %d\n", n, dep, m);
			exit(0);
		}
		if(p) push(p);
		divide2(n - 1, dep + 1, m - p);
	}
	else
	{
		int p = 0;
		while(p <= m && (!fNTT[dep + 1][p] || !fNTT[dep + 1][m - p])) p++;
		if(p > m)
		{
			printf("n = %d, dep = %d, m = %d\n", n, dep, m);
			exit(0);
		}
		divide2(n / 2, dep + 1, p);
		divide2(n / 2, dep + 1, m - p);
	}
}

void solve()
{
	for(len = 1; len <= m + m; len <<= 1);
	for(int i = 0; i < len; i++) tr[i] = (tr[i >> 1] >> 1) | ((i & 1) ? (len >> 1) : 0);
	for(int i = 1; i <= m; i++) fNTT[0][i] = gNTT[0][i] = !!from[i];
	fNTT[0][0] = gNTT[0][0] = 1;
	NTT(gNTT[0], len, tr, 0);
	divide1(m / S + 1, 1);
	if(!fNTT[1][m]) { printf("impossible\n"); return; }
	divide2(m / S + 1, 1, m);
	printf("possible\n");
	for(int _ = 0; _ < 2; _++)
	{
		printf("%d %d\n", v[_].size(), _);
		for(int x : v[_]) print(x, ' ');
		putc('\n');
	}
}
} // namespace Sub2


void solve()
{
	// memset(h, idx = -1, sizeof(h));
	n = read(), m = read();
	for(int i = 1, x; i <= n; i++) x = read(), from[x] = x;
	if(from[1])
	{
		for(int i = 1; i <= m; i++) if(!from[i]) s.insert(i);
		for(int i = 1; i <= m; i++) if(from[i] == i)
		{
			int l = i, r = std::min(m, 2 * i - 2);
			// printf("[%d %d]\n", l, r);
			for(auto it = s.lower_bound(l), nxt = it; it != s.end() && *it <= r; it = nxt)
				nxt = next(it), from[*it] = i, s.erase(it);
		}
		from[1] = 0;
	}
	S = 1;
	while(S <= m && !from[S]) S++;
	if(S > m) { printf("impossible\n"); return; }
	if(S <= 500) Sub1::solve();
	else Sub2::solve();
	// Sub1::solve();
}

void init()
{
	
}

char _ED_;

void mian()
{
	debug("%.3f MB\n", abs(&_ST_ - &_ED_) / 1024.0 / 1024);
	init(); int T = 1;
	for(; T; solve(), T--);
}

#ifdef int
	#undef int
#endif
}

int main()
{
	uvu::mian(); return 0;
}