// {{{ y0105w49 template 21N30
// hi mom
#ifndef NULL
// #include <bits/stdc++.h>
#include <bits/extc++.h>
#endif
#include <tr2/dynamic_bitset>
using namespace std;
#ifdef ARST
#define JO 1
#define OJ 0
#else
#define JO 0
#define OJ 1
#endif
#define STR(x) #x
#define GCCDIAG(s) _Pragma(STR(GCC diagnostic s)) static_assert(true)
#define Wsave GCCDIAG(push)
#define Wpop GCCDIAG(pop)
#define Wsupp(w) GCCDIAG(ignored "-W" w)
#define Wpush(w) Wsave; Wsupp(w)
#define typeof __typeof__
namespace gbd_ns {
	template<typename C>
	struct is_iterable {
		template<class T> static long check(...);
		template<class T> static char check(int,typename T::const_iterator = C().end());
		enum {
			value = sizeof(check<C>(0)) == sizeof(char),
			neg_value = sizeof(check<C>(0)) != sizeof(char)
		};
	};
	template<class T> struct _gbd3C;
	template<class T> ostream &_gbd3(ostream &os,const T &x) {
		return _gbd3C<T>::call(os,x);
	}
	template<> ostream &_gbd3(ostream &os,const string &x) {
		return os<<'"'<<x<<'"';
	}
	template<> ostream &_gbd3(ostream &os,char *const &x) {
		return os<<'"'<<x<<'"';
	}
	template<class T> ostream &_gbd35(ostream &os,const T &x) {
		return _gbd3(os,x);  // why??
	}
	template<class A,class B>
	ostream &_gbd4(ostream &os,const pair<A,B> &p) {
		_gbd3(os<<'(',p.first);
		_gbd3(os<<',',p.second);
		return os<<')';
	}
	template<class T,size_t N> struct _gbd4_tupleC {
		static void call(ostream &os,const T &t) {
			_gbd4_tupleC<T,N-1>::call(os,t);
			os<<','<<get<N-1>(t);
		}
	};
	template<class T> struct _gbd4_tupleC<T,1> {
		static void call(ostream &os,const T &t) {
			os<<get<0>(t);
		}
	};
	template<typename... Types>
	ostream &_gbd4(ostream &os,const tuple<Types...> &t) {
		os<<'(';
		_gbd4_tupleC<tuple<Types...>,sizeof...(Types)>::call(os,t);
		return os<<')';
	}
	template<>
	ostream &_gbd4(ostream &os,const tuple<> &t) { (void)t; return os<<"()"; }
	template<class T> ostream &_gbd4(ostream &os,const T &x) {
		return os<<x;
	}
	template<class T> struct _gbd3C {
		template<class U=T>
		static ostream &call(ostream &os,enable_if_t<is_iterable<U>::value,const T> &V) {
			os<<"{";
			bool ff=0;
			for(const auto &E:V) _gbd35<decltype(E)>(ff?os<<",":os,E), ff=1;
			return os<<"}";
		}
		template<class U=T>
		static ostream &call(ostream &os,enable_if_t<is_iterable<U>::neg_value,const T> &x) {
			return _gbd4(os,x);
		}
	};
	template<class T,typename... Args> ostream &_gbd2(ostream &os,bool,vector<string>::iterator nm,const T &x,Args&&... args);
	ostream &_gbd2(ostream &os,bool,vector<string>::iterator) { return os; }
	template<typename... Args>
	ostream &_gbd2(ostream &os,bool fi,vector<string>::iterator nm,const char *x,Args&&... args) {
		return _gbd2(os<<(fi?"":"  ")<<x,0,nm+1,args...);
	}
	template<class T,typename... Args>
	ostream &_gbd2(ostream &os,bool fi,vector<string>::iterator nm,const T &x,Args&&... args) {
		return _gbd2(_gbd3<T>(os<<(fi?"":"  ")<<*nm<<"=",x),0,nm+1,args...);
	}
	vector<string> split(string s) {
		vector<string> Z;
		string z="";
		s+=',';
		int dep=0;
		for(char c:s) {
			if(c==',' && !dep) Z.push_back(z),z="";
			else z+=c;
			if(c=='(' || c=='{' || c=='[') ++dep;
			if(c==')' || c=='}' || c==']') --dep;
		}
		return Z;
	}
	template<typename... Args> ostream &_gbd1(ostream &os,const string &nm,Args&&... args) {
		return _gbd2(os,1,split(nm).begin(),args...);
	}
	template<typename... Args> string _gbd1(const string &nm,Args&&... args) {
		ostringstream oss;
		_gbd2(oss,1,split(nm).begin(),args...);
		return oss.str();
	}
}
bool DBG=1,EMACS=0;
#define dbg(...) (JO&&DBG?gbd_ns::_gbd1(cerr<<"\033[38;5;5m"<<__FILE__<<":"<<__LINE__<<(EMACS?":note: ":": "),#__VA_ARGS__,__VA_ARGS__)<<"\033[0m"<<endl:cerr)
#define dbgt(...) dbg(fmt_time(),__VA_ARGS__)
#define fmt(...) gbd_ns::_gbd1(#__VA_ARGS__,__VA_ARGS__)
template<class Fun> struct _y_combinator_result {
	Fun _fun;
	template<class T> explicit _y_combinator_result(T &&fun) : _fun(forward<T>(fun)) {}
	template<typename... Args> decltype(auto) operator()(Args &&... args) {
		return _fun(ref(*this),forward<Args>(args)...);
	}
};
template<class Fun> [[nodiscard]] decltype(auto) fix(Fun &&fun) {
	return _y_combinator_result<decay_t<Fun>>(forward<Fun>(fun));
}
#define nop void()
#define sz(x) (int((x).size()))
#define all(v) begin(v),end(v)
#define sortu(v) (sort(all(v)), (v).resize(unique(all(v))-begin(v)))
#define forenum(i,...) for(int i:{-1}) for(__VA_ARGS__) if(++i,0) assert(0); else
#define forenumll(i,...) for(long long i:{-1}) for(__VA_ARGS__) if(++i,0) assert(0); else
#define forbs(k,i,bs) for(ptrdiff_t k=0,i=(bs)._Find_first();i<(ptrdiff_t)(bs).size();i=(bs)._Find_next(i),++k)
#define get(x,i) get<i>(x)
template<class T> bool inb(const T &x,const T &l,const T &r) { return l<=x&&x<=r; }
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
template<class S,class T> using omap=__gnu_pbds::tree<S,T,less<S>,__gnu_pbds::rb_tree_tag,__gnu_pbds::tree_order_statistics_node_update>;
template<class T> using oset=omap<T,__gnu_pbds::null_type>;
template<class T> using rope=__gnu_cxx::rope<T>;
using dbitset=tr2::dynamic_bitset<>;
const int e0=1, e1=10, e2=100, e3=1000;
const int e4=10*e3, e5=100*e3, e6=1000*e3;
const int e7=10*e6, e8=100*e6, e9=1000*e6;
const long long e12=1LL*e3*e9, e15=1LL*e6*e9, e18=1LL*e9*e9;
using ulll=__uint128_t;
using lll=__int128_t;
using ull=unsigned long long;
using ll=long long;
unsigned long long START_TIME=chrono::duration_cast<chrono::microseconds>(chrono::steady_clock::now().time_since_epoch()).count();
inline unsigned long long now_U_03BC_s() { return chrono::duration_cast<chrono::microseconds>(chrono::steady_clock::now().time_since_epoch()).count()-START_TIME; }
const char *fmt_time(unsigned long long U_03BC_s=now_U_03BC_s()) { static char dur[20]; sprintf(dur,"%llu.%03llus",U_03BC_s/e6,(U_03BC_s%e6)/e3); return dur; }
#define timed(cb) do { dbg("timed "#cb" ..."); unsigned long long start=now_U_03BC_s(); cb; dbg("timed "#cb" took",fmt_time(now_U_03BC_s()-start)); } while(0)
int arg1; bool inp; vector<string> args;
unsigned seed=JO&&getenv("sd")?atoi(getenv("sd")):unsigned(OJ?START_TIME:START_TIME%e5);
mt19937 igen(seed<<1),gen(seed<<1|1);
#define irand(...) _rand(igen,__VA_ARGS__)
#define rand(...) _rand(gen,__VA_ARGS__)
template<class T> enable_if_t<numeric_limits<T>::is_integer,T> _rand(mt19937 &g,T l,T r) { return uniform_int_distribution<T>(l,r)(g); }
template<class T> enable_if_t<numeric_limits<T>::is_integer,T> _rand(mt19937 &g,T n) { return _rand(g,T(1),n); }
[[deprecated]] int _rand(mt19937 &g) { return _rand(g,0,numeric_limits<int>::max()); }
template<class T> enable_if_t<numeric_limits<T>::is_iec559,T> _rand(mt19937 &g,T l,T r) { return uniform_real_distribution<T>(l,r)(g); }
bool _rand(mt19937 &g,double p) { return bernoulli_distribution(p)(g); }
template<class T> T _rand(mt19937 &g,initializer_list<T> il) { return *(il.begin()+_rand(g,0,(int)il.size()-1)); }
template<class T> T _rand(mt19937 &g,double p,T a,T b) { return _rand(g,p)?a:b; }
template<class T> T _rand(mt19937 &g,initializer_list<T> il,initializer_list<double> wt) { assert(il.size()==wt.size()); return *(il.begin()+discrete_distribution(wt)(g)); }
#define random_shuffle(...) static_assert(false,"random_shuffle deprecated, use shuffle")
#define ine(x,e) (inp?cin>>(x),nop:((x)=(e),nop))
#define inr(x,...) ine(x,irand(__VA_ARGS__))
#define endl '\n'
string garb;
void exit0() { dbg("finished (early) in",fmt_time()); exit(0); }
#ifndef MAIN
#define MAIN _main
#endif
void MAIN();
int32_t main([[maybe_unused]]int argc,[[maybe_unused]]char *argv[]) {
	ios_base::sync_with_stdio(0); cin.tie(0); cin.exceptions(ios_base::failbit | ios_base::badbit);
	arg1=0,args={argv,argv+argc};
	if(sz(args)>1) {
		if(args[1][0]=='i') freopen((string(__FILE__).substr(0,string(__FILE__).find('.'))+"."+args[1].substr(1)+".in").c_str(),"r",stdin);
		else if(args[1][0]=='I') freopen(args[1].substr(1).c_str(),"r",stdin);
		else arg1=stoi(args[1]);
	}
	inp=!arg1;
	if(JO && getenv("EMACS")) EMACS=1;
	dbgt(arg1,seed,args);
	MAIN();
	dbgt("gg;wp");
}
using flt=double; //CARE
const flt U_03B5_=(flt)1e-8;
const flt U_03C4_=(flt)(2*acosl(-1));
const int inf=e9+99;
const ll linf=1LL*e9*e9+99;
// }}}
const int P=e9+7;//998'244'353;










void _main() { /* CURSOR START */
	const int N=160;
	int n,m,nspc; cin>>n>>m>>nspc;
	assert(inb(n,1,150) && inb(m,1,n*(n-1)/2) && inb(nspc,1,m));
	static bitset<N> spc[N],nrm[N];
	static char A[N][N];
	for(int i=1;i<=m;i++) {
		int u,v; cin>>u>>v;
		assert(1<=u && u<v && v<=n);
		assert(!spc[u][v] && !nrm[u][v]);
		(i<=nspc?spc:nrm)[u][v]=1;
		(i<=nspc?spc:nrm)[v][u]=1;
		A[u][v]=A[v][u]="NS"[i<=nspc];
	}
	assert((cin>>ws).eof());
	auto check=[&](vector<int> Z) -> void {
		dbg("checking",Z);
		int l=sz(Z);
		assert(inb(l,3,n));
		for(int x:Z) assert(inb(x,1,n));
		for(int i=0;i<l;i++) for(int j=0;j<i;j++) assert(Z[i]!=Z[j]);
		int y=Z.back();
		for(int x:Z) assert(A[x][y]=='N' || A[x][y]=='S'), A[x][y]=A[y][x]=0, y=x;
		for(int x:Z) for(y=1;y<=n;y++) assert(A[x][y]==0 || A[x][y]=='N');
	};

	auto dfs=fix([&](auto rec,vector<pair<int,int>> &br,bitset<N> &vis,int u,int d=0,int p=-1) -> int {
		static int dep[N];
		if(vis[u]) return dep[u];
		vis[u]=1, dep[u]=d;
		int z=d;
		forbs(_,v,nrm[u]) if(v!=p) z=min(z,rec(br,vis,(int)v,d+1,u));
		forbs(_,v,spc[u]) if(v!=p) z=min(z,rec(br,vis,(int)v,d+1,u));
		if(z==d && ~p) br.pb({u,p});
		return z;
	});
	auto solve=fix([&](auto rec,bitset<N> V) -> vector<int> {
			forbs(_,u,V) assert(!spc[u][u]);
			forbs(_,u,V) assert(!spc[u][u] && !nrm[u][u]);
			forbs(_,u,V) assert((spc[u]&nrm[u]).none() && !spc[u][u] && !nrm[u][u]);

			if(V.count()<=2) return {};
			forbs(_,u,V) if(spc[u].count()>=3) {
				vector<int> Q={(int)u};
				for(int ii=0;ii<sz(Q);ii++) {
					u=Q[ii];
					V[u]=0;
					forbs(__,v,spc[u]) if(V[v]) Q.pb((int)v);
					forbs(__,v,nrm[u]) nrm[v][u]=0;
				}
				dbg("rec cut 3-spc",Q);
				return rec(V);
			}
			forbs(_,u,V) if(spc[u].count()==2) {
				int x=(int)spc[u]._Find_first();
				int y=(int)spc[u]._Find_next(x);
				assert(spc[u]._Find_next(y)==N);
				assert(x!=y && V[x] && V[y]);
				spc[x][u]=spc[u][x]=0;
				spc[y][u]=spc[u][y]=0;
				if(nrm[x][y] && spc[x].none() && spc[y].none()) { dbg("ssn",x,y,u); return {x,y,(int)u}; };
				if(spc[x][y]) { assert(spc[x].count()==1 && spc[y].count()==1); dbg("sss",x,y,u); return {x,y,(int)u}; }
				spc[x][y]=spc[y][x]=1;
				nrm[x][y]=nrm[y][x]=0;
				forbs(__,v,nrm[u]) nrm[v][u]=0;
				V[u]=0;
				dbg("rec compress 2-spc",u,x,y);
				auto Z=rec(V);
				dbg("ret 2spc",Z);
				forenum(j,int v:Z) if(v==x || v==y) {
					if(Z[j+1]==(x^y^v)) Z.insert(Z.begin()+j+1,(int)u);
					else assert(!j && Z.back()==(x^y^v)), Z.pb((int)u);
					return Z;
				}
				return Z;
			}
			forbs(_,u,V) assert(spc[u].count()<=1);

			vector<pair<int,int>> br;
			bitset<N> vis;
			dfs(br,vis,(int)V._Find_first());
			assert(vis[V._Find_first()]);
			if(vis.count()<V.count()) {
				dbg("rec first dj cc");
				auto Z=rec(vis);
				if(sz(Z)) return Z;
				dbg("rec second dj cc");
				return rec(V&~vis);
			}
			assert(vis.count()==V.count());
			if(sz(br)) {
				dbg(br);
				for(auto [u,v]:br) {
					assert(nrm[u][v]+spc[u][v]==1);
					if(spc[u][v]) {
						forbs(_,w,nrm[u]) nrm[w][u]=0;
						forbs(_,w,nrm[v]) nrm[w][v]=0;
						spc[u][v]=spc[v][u]=0;
						V[u]=V[v]=0;
					} else nrm[u][v]=nrm[v][u]=0;
				}
				dbg("rec killedbr",br);
				return rec(V);
			}

			auto nrmV=V;
			forbs(_,u,V) nrmV&=~spc[u];
			if(nrmV.any()) {
				int u=(int)nrmV._Find_first();
				assert(spc[u].none());

				// forbs(_,v,nrm[u]) forbs(__,w,nrm[u]) {
				// 	if(v!=w && spc[v][w]) { dbg("nns",u,v,w); return {u,(int)v,(int)w}; }
				// 	if(v!=w && nrm[v][w] && nrmV[v] && nrmV[w]) { dbg("nnn"); return {u,(int)v,(int)w}; }
				// }
				forbs(_,v,nrm[u]) if((nrm[u]&spc[v]).any()) {
					int w=(int)(nrm[u]&spc[v])._Find_first();
					dbg("nns",u,v,w);
					return {u,(int)v,(int)w};
				}
				forbs(_,v,nrm[u]) if(nrmV[v] && (nrm[u]&nrm[v]&nrmV).any()) {
					int w=(int)(nrm[u]&nrm[v]&nrmV)._Find_first();
					dbg("nnn",u,v,w);
					return {u,(int)v,(int)w};
				}

				forbs(_,v,nrm[u]) if(nrmV[v]) {
					assert(spc[v].none());
					V[v]=0;
					nrm[u]|=nrm[v];
					forbs(__,w,nrm[v]) if(nrm[w][v]) nrm[w][v]=0, nrm[w][u]=1;
					nrm[u][u]=0;
					dbg("rec compress adj nrm",u,v);
					auto Z=rec(V);
					dbg("ez fixing",Z);
					assert(sz(Z));
					auto it=find(all(Z),u);
					if(it==Z.end()) return Z;
					bool fv=nrm[v][it+1==Z.end()?Z[0]:*(it+1)];
					bool rv=nrm[v][it==Z.begin()?Z.back():*(it-1)];
					if(fv && rv) return *it=(int)v,Z;
					if(fv) Z.insert(it+1,(int)v);
					if(rv) Z.insert(it,(int)v);
					return Z;
				}

				// forbs(_,v,nrm[u]) forbs(__,w,nrm[u]) if(v!=w) assert(!spc[v][w]), nrm[v][w]=nrm[w][v]=1;
				forbs(_,v,nrm[u]) nrm[v]|=nrm[u];
				forbs(_,v,nrm[u]) nrm[v][u]=nrm[v][v]=0;
				V[u]=0;
				dbg("rec compress lone nrm",u);
				auto Z=rec(V);
				assert(sz(Z));
				vector<int> NZ;
				int pr=Z.back();
				for(int v:Z) {
					if(nrm[u][v] && nrm[u][pr]) NZ.pb(u);
					NZ.pb(v);
					pr=v;
				}
				dbg("multi-fixed",NZ);
				rotate(NZ.begin(),find(all(NZ),u),NZ.end());
				NZ.erase(find(NZ.begin()+1,NZ.end(),u),NZ.end());
				dbg("trunc'd",NZ);
				return NZ;
			}

			forbs(_,u,V) assert(spc[u].count()==1 && nrm[u].any());
			static int mat[N];
			forbs(_,u,V) mat[u]=(int)spc[u]._Find_first();

			bitset<N> seen;
			vector<int> cyc1;
			for(int u=(int)V._Find_first();;) {
				if(seen[u]) {
					dbg("found good-cyc",u,mat[u],cyc1);
					reverse(all(cyc1));
					for(;cyc1.back()!=u;) cyc1.pop_back();
					dbg("returning",cyc1);
					return cyc1;
				}
				cyc1.pb(u);
				seen[u]=1;
				u=mat[u];
				if(seen[u]) break;
				cyc1.pb(u);
				u=(int)nrm[u]._Find_first();
			}
			dbg("broke w/ first cyc",cyc1);
			reverse(all(cyc1));
			for(;cyc1.back()!=cyc1[0];) cyc1.pop_back();
			assert(sz(cyc1)>=4 && sz(cyc1)%2==0);
			dbg("nz",cyc1);

			auto cut_cyc=[](vector<int> cyc,int u) -> vector<int> {
				if(u==cyc.back()) return {u};
				int v=mat[u];
				int w=cyc.back(); cyc.pop_back();
				assert(u!=w && v!=w);
				rotate(cyc.begin(),find(all(cyc),u),cyc.end());
				assert(cyc[0]==u);
				if(cyc[1]!=v) reverse(cyc.begin()+1,cyc.end());
				assert(cyc[1]==v);
				for(;cyc.back()!=w;) cyc.pop_back();
				return cyc;
			};

			seen.reset();
			for(int u:cyc1) seen[u]=1;
			seen[cyc1.back()]=0;
			vector<int> cyc2;
			for(int u=cyc1.back();;) {
				if(seen[u]) {
					dbg("found some good-cyc (2)",u,mat[u],cyc1,cyc2);
					auto it=find(all(cyc2),u);
					if(it!=cyc2.end()) {
						cyc2.erase(cyc2.begin(),it);
						dbg("returning",cyc2);
						return cyc2;
					}
					dbg("ret join",cyc1,cyc2);
					assert(cyc2[0]==cyc1.back());
					auto Z=cut_cyc(cyc1,u);
					assert(Z.back()==cyc2[0]); Z.pop_back();
					Z.insert(Z.end(),all(cyc2));
					dbg("joined",Z);
					return Z;
				}
				cyc2.pb(u);
				seen[u]=1;
				u=mat[u];
				if(seen[u]) break;
				cyc2.pb(u);
				u=(int)nrm[u]._Find_first();
			}
			dbg("broke w/ second cyc",cyc2);
			reverse(all(cyc2));
			vector<int> pat;
			for(;cyc2.back()!=cyc2[0];) pat.pb(cyc2.back()), cyc2.pop_back();
			assert(sz(cyc2)>=4 && sz(cyc2)%2==0);
			dbg("nz",cyc2);
			pat.pb(cyc2.back());

			for(;;) {
				dbg("looping w/ state",cyc1,pat,cyc2);
				seen.reset();
				static bitset<N> stop; stop.reset();
				for(int u:cyc1) stop[u]=1;
				for(int u:pat) stop[u]=1;
				// stop[cyc2.back()]=0;
				auto Q=cyc2; Q.pop_back();
				for(int u:Q) seen[u]=1;
				Q[0]=-1;
				static int pr[N]; memset(pr,-1,sizeof pr);
				for(int ii=0;;ii++) {
					assert(ii<sz(Q));
					int u=Q[ii];
					if(!~u) u=cyc2.back();
					else if(stop[u]) {
						u=mat[u];
						dbg("stopped search",u,mat[u],pr[u],pr[mat[u]]);
						vector<int> Z;
						if(find(all(cyc1),u)!=cyc1.end()) {
							dbg("final win CDCP");
							Z=cut_cyc(cyc1,u);
							assert(Z.back()==pat[0]); Z.pop_back();
							for(int v:pat) Z.pb(v);
							finish:;
							assert(Z.back()==cyc2.back());
							reverse(all(Z));
							dbg("half-cyc and pat",Z);
							// for(;~pr[Z.back()];) Z.pb(pr[Z.back()]), Z.pb(mat[Z.back()]);
							for(;~pr[Z.back()] && (mat[Z.back()]!=cyc2.back() || sz(Z)<=2);)
								Z.pb(pr[Z.back()]), Z.pb(mat[Z.back()]);
							dbg("and prs",Z);
							Z.pop_back(); assert(!~pr[Z.back()]);
							auto las=cut_cyc(cyc2,Z.back());
							assert(las[0]==Z.back());
							Z.pop_back();
							Z.insert(Z.end(),all(las));
							assert(Z.back()==Z[0]);
							Z.pop_back();
							dbg("aaand finally",Z);
							return Z;
						}
						auto it=find(all(pat),u);
						assert(it!=pat.begin() && it!=pat.end()-1);
						Z={it,pat.end()};
						if(*(it+1)==mat[u]) {
							dbg("final win CDP. being cute w/",Z);
							goto finish;
						}
						dbg("shortening",sz(pat),"to",it+1-pat.begin());
						reverse(all(Z));
						// for(;~pr[Z.back()];) Z.pb(pr[Z.back()]), Z.pb(mat[Z.back()]);
						for(;~pr[Z.back()] && (mat[Z.back()]!=cyc2.back() || sz(Z)<=2);)
							Z.pb(pr[Z.back()]), Z.pb(mat[Z.back()]);
						dbg("half-pat and back",Z);
						Z.pop_back(); assert(!~pr[Z.back()]);
						cyc2=cut_cyc(cyc2,Z.back());
						assert(cyc2[0]==Z.back());
						assert(cyc2.back()==Z[0]);
						cyc2.pop_back();
						Z.pop_back();
						cyc2.insert(cyc2.begin(),all(Z));
						pat.erase(it+1,pat.end());
						rotate(cyc2.begin(),find(all(cyc2),pat.back()),cyc2.end());
						cyc2.pb(cyc2[0]);
						break;
					}
					static bitset<N> tmp; tmp=nrm[u]&~seen;
					forbs(_,v,tmp) seen[v]=1, pr[v]=u, Q.pb(mat[v]);
				}
			}
		});

	bitset<N> V; for(int i=1;i<=n;i++) V[i]=1;
	auto Z=solve(V);
	if(!sz(Z)) return cout<<-1<<endl,nop;
	check(Z);
	cout<<sz(Z)<<endl;
	forenum(i,int x:Z) cout<<x<<" \n"[i==sz(Z)-1];
}