#include <bits/stdc++.h>

using namespace std;

const int maxn = 5e5+100;

vector<int> g[maxn],leave;
int dep[maxn];
bool vis[maxn];
int n,m,k;

void pt(int s,int e){
	if(s==e){
		cout<<s<<" ";
	 	return;
	}
	for(auto i:g[s]){
		if(dep[i]==dep[s]-1){
			cout<<s<<" ";
			pt(i,e);
			break;
		}
	}
}

bool dfs(int u,int d){
	dep[u]=d;
	if(d>=n/k){
		cout<<"PATH"<<endl;
		cout<<d<<endl;
		pt(u,1);
		cout<<endl;
		return true;
	}
	bool flag=1;
	for(auto i:g[u]){
		if(dep[i]) continue;
		flag=0;
		if(dfs(i,d+1)){
			return true;
		}
	}
	if(flag){
		leave.push_back(u);
	}
	return false;
}

int main(){

	ios::sync_with_stdio(false);
	cin.tie(0);
	int a,b;
	cin>>n>>m>>k;
	for(int i=0;i<m;++i){
		cin>>a>>b;
		g[a].push_back(b);
		g[b].push_back(a);
	}
	if(!dfs(1,1)){
		cout<<"CYCLES"<<endl;
		for(auto le:leave){
			int x=0,y=0;
			for(auto i:g[le]){
				if(dep[i]!=dep[le]-1){
					if(!x){
						x=i;
					}else{
						y=i;
						break;
					}
				}
			}
			if((dep[le]-dep[x]+1)%3){
				cout<<dep[le]-dep[x]+1<<endl;
				pt(le,x);
				cout<<endl;
			}else if((dep[le]-dep[y]+1)%3){
				cout<<dep[le]-dep[y]+1<<endl;
				pt(le,y);
				cout<<endl;
			}else{
				if(dep[x]>dep[y]) swap(x,y);
				cout<<dep[x]-dep[y]+2<<endl;
				cout<<le<<" ";
				pt(y,x);
				cout<<endl;
			}
			--k;
			if(!k){
				break;
			}
		}
	}
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

const int maxn = 5e5+100;

vector<int> g[maxn],leave;
int dep[maxn];
bool vis[maxn];
int n,m,k;

void pt(int s,int e){
	if(s==e){
		cout<<s<<" ";
	 	return;
	}
	for(auto i:g[s]){
		if(dep[i]==dep[s]-1){
			cout<<s<<" ";
			pt(i,e);
			break;
		}
	}
}

bool dfs(int u,int d){
	dep[u]=d;
	if(d>=n/k){
		cout<<"PATH"<<endl;
		cout<<d<<endl;
		pt(u,1);
		cout<<endl;
		return true;
	}
	bool flag=1;
	for(auto i:g[u]){
		if(dep[i]) continue;
		flag=0;
		if(dfs(i,d+1)){
			return true;
		}
	}
	if(flag){
		leave.push_back(u);
	}
	return false;
}

int main(){

	ios::sync_with_stdio(false);
	cin.tie(0);
	int a,b;
	cin>>n>>m>>k;
	for(int i=0;i<m;++i){
		cin>>a>>b;
		g[a].push_back(b);
		g[b].push_back(a);
	}
	if(!dfs(1,1)){
		cout<<"CYCLES"<<endl;
		for(auto le:leave){
			int x=0,y=0;
			for(auto i:g[le]){
				if(dep[i]!=dep[le]-1){
					if(!x){
						x=i;
					}else{
						y=i;
						break;
					}
				}
			}
			if((dep[le]-dep[x]+1)%3){
				cout<<dep[le]-dep[x]+1<<endl;
				pt(le,x);
				cout<<endl;
			}else if((dep[le]-dep[y]+1)%3){
				cout<<dep[le]-dep[y]+1<<endl;
				pt(le,y);
				cout<<endl;
			}else{
				if(dep[x]>dep[y]) swap(x,y);
				cout<<dep[y]-dep[x]+2<<endl;
				cout<<le<<" ";
				pt(y,x);
				cout<<endl;
			}
			--k;
			if(!k){
				break;
			}
		}
	}
	return 0;
}


#pragma comment(linker, "/STACK:1677721600")

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <unordered_set>
#include <vector>
#include <memory.h>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <stdio.h>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <random>
#include <string>
#include <cassert>

using namespace std;

string to_string(string const &s) { return '"' + s + '"'; }
string to_string(char c) { return string(1, c); }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) { string s = "["; for (int qwe=0;qwe<v.size();qwe++) { s += to_string(v[qwe]) + ","; }s += "]"; return s; }
template <class T1, class T2>string to_string(pair<T1, T2> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <class T>string to_string(T c) { string s = "["; for (auto vvv : c) { s += to_string(vvv) + ","; }s += "]"; return s; }
void debug_impl() { cerr << endl; };
template <typename T1, typename... T2>void debug_impl(T1 a, T2... b) { cerr << " " << to_string(a); debug_impl(b...); }

#ifdef __ASD__
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_impl(__VA_ARGS__)
#else
#define dbg(...) ;
#endif
#define lng long long

vector<vector<int>> grav;
vector<int> d;
vector<bool> was;
vector<bool> leaf;

void dfs(int u, int p) {
	d[u]=(p==-1)?1:d[p]+1;
	was[u]=true;
	for(int v:grav[u]) {
		if (v!=p&&!was[v]) {
			dfs(v, u);
			leaf[u]=false;
		}
	}
}

int main() {
#ifdef __ASD__
	freopen("input.txt", "r", stdin);
	//freopen("nul", "w", stderr);
	//freopen("output.txt", "w", stdout);
	auto start_t = chrono::steady_clock::now();
#else
	ios_base::sync_with_stdio(false);
#endif

	int n, m, k;
	cin >> n >> m >> k;

	grav.resize(n);
	d.resize(n);
	was.resize(n);
	leaf.resize(n, true);

	for(int i=0;i<m;i++) {
		int u, v;
		cin >> u >> v;
		u--; v--;
		grav[u].push_back(v);
		grav[v].push_back(u);
	}

	dfs(0, -1);

	int l=0;

	for(int i=0;i<n;i++) {
		if (d[i]>=(n+k-1)/k) {
			vector<int> path;

			while (i!=0) {
				path.push_back(i);
				for(int j:grav[i]) {
					if (j==0||d[j]==d[i]-1) {
						i=j;break;
					}
				}
			}
			path.push_back(i);

			reverse(path.begin(), path.end());

			cout << "PATH" << endl;
			cout << path.size() << endl;
			for(int x:path)cout<<x+1<<" ";
			cout<< endl;
			return 0;
		}
	}
	int c=0;
	for(int i=0;i<n;i++)dbg(i, grav[i]);

	cout << "CYCLES" << endl;

	for(int i=0;i<n;i++) {
		if (leaf[i]) {
			vector<int> cycle;

			for(int j : grav[i]) {
				if ((d[i] - d[j])%3!=2 && d[i]-d[j]!=1) {
					int x = i;
					while (x!=j) {
						cycle.push_back(x);
						for(int y:grav[x])if(d[y]==d[x]-1){x=y;break;}
					}
					cycle.push_back(x);
					break;
				}
			}
			if (cycle.empty()) {
				int u, v;
				for(int j : grav[i]) {
					if ((d[i] - d[j])%3==2) {
						if (u==-1) {
							u = j;
						} else if (v==-1) {
							v=j;
							break;
						}
					}
				}
				if (d[u] < d[v]) swap(u, v);
				while (u!=v) {
					cycle.push_back(u);
					for(int y:grav[u])if(d[y]==d[u]-1){u=y;break;}
				}
				cycle.push_back(u);
			}

			cout << cycle.size() << endl;
			for(int x:cycle)cout<<" " << x+1;
			cout << endl;
			c++;
			if (c==k)return 0;
		}
	}

#ifdef __ASD__
	auto finish_t = chrono::steady_clock::now();
	cerr << "Elapsed " << chrono::duration_cast<chrono::milliseconds>(finish_t - start_t).count() << " ms" << endl;
#endif
	return 0;
}


#pragma comment(linker, "/STACK:1677721600")

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <unordered_set>
#include <vector>
#include <memory.h>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <stdio.h>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <random>
#include <string>
#include <cassert>

using namespace std;

string to_string(string const &s) { return '"' + s + '"'; }
string to_string(char c) { return string(1, c); }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) { string s = "["; for (int qwe = 0; qwe < v.size(); qwe++) { s += to_string(v[qwe]) + ","; }s += "]"; return s; }
template <class T1, class T2>string to_string(pair<T1, T2> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <class T>string to_string(T c) { string s = "["; for (auto vvv : c) { s += to_string(vvv) + ","; }s += "]"; return s; }
void debug_impl() { cerr << endl; };
template <typename T1, typename... T2>void debug_impl(T1 a, T2... b) { cerr << " " << to_string(a); debug_impl(b...); }

#ifdef __ASD__
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_impl(__VA_ARGS__)
#else
#define dbg(...) ;
#endif
#define lng long long

vector<vector<int>> grav;
vector<int> d;
vector<bool> was;
vector<bool> leaf;
vector<int> par;

void dfs(int u, int p) {
	par[u] = p;
	d[u] = (p == -1) ? 1 : d[p] + 1;
	was[u] = true;
	for (int v : grav[u]) {
		if (v != p && !was[v]) {
			dfs(v, u);
			leaf[u] = false;
		}
	}
}

int main() {
#ifdef __ASD__
	freopen("input.txt", "r", stdin);
	//freopen("nul", "w", stderr);
	//freopen("output.txt", "w", stdout);
	auto start_t = chrono::steady_clock::now();
#else
	ios_base::sync_with_stdio(false);
#endif

	int n, m, k;
	cin >> n >> m >> k;

	grav.resize(n);
	d.resize(n);
	was.resize(n);
	leaf.resize(n, true);
	par.resize(n);

	for (int i = 0; i < m; i++) {
		int u, v;
		cin >> u >> v;
		u--; v--;
		grav[u].push_back(v);
		grav[v].push_back(u);
	}

	dfs(0, -1);

	int l = 0;

	for (int i = 0; i < n; i++) {
		if (d[i] >= (n + k - 1) / k) {
			vector<int> path;

			while (i != 0) {
				path.push_back(i);
				for (int j : grav[i]) {
					if (d[j] == d[i] - 1) {
						i = j; break;
					}
				}
			}
			path.push_back(i);

			reverse(path.begin(), path.end());

			cout << "PATH" << endl;
			cout << path.size() << endl;
			for (int x : path)cout << x + 1 << " ";
			cout << endl;
			return 0;
		}
	}
	int c = 0;
	for (int i = 0; i < n; i++)dbg(i, grav[i]);

	printf("CYCLES\n");

	vector<int> cycle;
	for (int i = 0; i < n; i++) {
		if (leaf[i]) {
			cycle.clear();
			for (int j : grav[i]) {
				if ((d[i] - d[j]) % 3 != 2 && d[i] - d[j] != 1) {
					int x = i;
					while (x != j) {
						cycle.push_back(x);
						x = par[x];
					}
					cycle.push_back(x);
					break;
				}
			}
			if (cycle.empty()) {
				int u=-1, v=-1;
				for (int j : grav[i]) {
					if ((d[i] - d[j]) % 3 == 2) {
						if (u == -1) {
							u = j;
						}
						else if (v == -1) {
							v = j;
							break;
						}
					}
				}
				if (d[u] < d[v]) swap(u, v);
				while (u != v) {
					cycle.push_back(u);
					u = par[u];
				}
				cycle.push_back(u);
				cycle.push_back(i);
			}

			printf("%d\n", cycle.size());
			for (int x : cycle)printf("%d ", x + 1);
			printf("\n");
			c++;
			if (c == k)return 0;
		}
	}

#ifdef __ASD__
	auto finish_t = chrono::steady_clock::now();
	cerr << "Elapsed " << chrono::duration_cast<chrono::milliseconds>(finish_t - start_t).count() << " ms" << endl;
#endif
	return 0;
}


#pragma comment(linker, "/STACK:1677721600")

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <unordered_set>
#include <vector>
#include <memory.h>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <stdio.h>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <random>
#include <string>
#include <cassert>

using namespace std;

string to_string(string const &s) { return '"' + s + '"'; }
string to_string(char c) { return string(1, c); }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) { string s = "["; for (int qwe=0;qwe<v.size();qwe++) { s += to_string(v[qwe]) + ","; }s += "]"; return s; }
template <class T1, class T2>string to_string(pair<T1, T2> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <class T>string to_string(T c) { string s = "["; for (auto vvv : c) { s += to_string(vvv) + ","; }s += "]"; return s; }
void debug_impl() { cerr << endl; };
template <typename T1, typename... T2>void debug_impl(T1 a, T2... b) { cerr << " " << to_string(a); debug_impl(b...); }

#ifdef __ASD__
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_impl(__VA_ARGS__)
#else
#define dbg(...) ;
#endif
#define lng long long

vector<vector<int>> grav;
vector<int> d;
vector<bool> was;
vector<bool> leaf;
vector<int> par;

void dfs(int u, int p) {
	par[u]=p;
	d[u]=(p==-1)?1:d[p]+1;
	was[u]=true;
	for(int v:grav[u]) {
		if (v!=p&&!was[v]) {
			dfs(v, u);
			leaf[u]=false;
		}
	}
}

int main() {
#ifdef __ASD__
	freopen("input.txt", "r", stdin);
	//freopen("nul", "w", stderr);
	//freopen("output.txt", "w", stdout);
	auto start_t = chrono::steady_clock::now();
#else
	ios_base::sync_with_stdio(false);
#endif

	int n, m, k;
	cin >> n >> m >> k;

	grav.resize(n);
	d.resize(n);
	was.resize(n);
	leaf.resize(n, true);
	par.resize(n);

	for(int i=0;i<m;i++) {
		int u, v;
		cin >> u >> v;
		u--; v--;
		grav[u].push_back(v);
		grav[v].push_back(u);
	}

	dfs(0, -1);

	int l=0;

	for(int i=0;i<n;i++) {
		if (d[i]>=(n+k-1)/k) {
			vector<int> path;

			while (i!=0) {
				path.push_back(i);
				for(int j:grav[i]) {
					if (d[j]==d[i]-1) {
						i=j;break;
					}
				}
			}
			path.push_back(i);

			reverse(path.begin(), path.end());

			cout << "PATH" << endl;
			cout << path.size() << endl;
			for(int x:path)cout<<x+1<<" ";
			cout<< endl;
			return 0;
		}
	}
	int c=0;
	for(int i=0;i<n;i++)dbg(i, grav[i]);

	cout << "CYCLES" << endl;

	for(int i=0;i<n;i++) {
		if (leaf[i]) {
			vector<int> cycle;

			for(int j : grav[i]) {
				if ((d[i] - d[j])%3!=2 && d[i]-d[j]!=1) {
					int x = i;
					while (x!=j) {
						cycle.push_back(x);
						x=par[x];
					}
					cycle.push_back(x);
					break;
				}
			}
			if (cycle.empty()) {
				int u, v;
				for(int j : grav[i]) {
					if ((d[i] - d[j])%3==2) {
						if (u==-1) {
							u = j;
						} else if (v==-1) {
							v=j;
							break;
						}
					}
				}
				if (d[u] < d[v]) swap(u, v);
				while (u!=v) {
					cycle.push_back(u);
					u=par[u];
				}
				cycle.push_back(u);
			}

			printf("%d\n", cycle.size());
			for(int x:cycle)printf("%d ", x);
			printf("\n");
			c++;
			if (c==k)return 0;
		}
	}

#ifdef __ASD__
	auto finish_t = chrono::steady_clock::now();
	cerr << "Elapsed " << chrono::duration_cast<chrono::milliseconds>(finish_t - start_t).count() << " ms" << endl;
#endif
	return 0;
}


#pragma comment(linker, "/STACK:1677721600")

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <unordered_set>
#include <vector>
#include <memory.h>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <stdio.h>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <random>
#include <string>
#include <cassert>

using namespace std;

string to_string(string const &s) { return '"' + s + '"'; }
string to_string(char c) { return string(1, c); }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) { string s = "["; for (int qwe = 0; qwe < v.size(); qwe++) { s += to_string(v[qwe]) + ","; }s += "]"; return s; }
template <class T1, class T2>string to_string(pair<T1, T2> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <class T>string to_string(T c) { string s = "["; for (auto vvv : c) { s += to_string(vvv) + ","; }s += "]"; return s; }
void debug_impl() { cerr << endl; };
template <typename T1, typename... T2>void debug_impl(T1 a, T2... b) { cerr << " " << to_string(a); debug_impl(b...); }

#ifdef __ASD__
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_impl(__VA_ARGS__)
#else
#define dbg(...) ;
#endif
#define lng long long

vector<vector<int>> grav;
vector<int> d;
vector<bool> was;
vector<bool> leaf;
vector<int> par;

void dfs(int u, int p) {
	par[u] = p;
	d[u] = (p == -1) ? 1 : d[p] + 1;
	was[u] = true;
	for (int v : grav[u]) {
		if (v != p && !was[v]) {
			dfs(v, u);
			leaf[u] = false;
		}
	}
}

int main() {
#ifdef __ASD__
	freopen("input.txt", "r", stdin);
	//freopen("nul", "w", stderr);
	//freopen("output.txt", "w", stdout);
	auto start_t = chrono::steady_clock::now();
#else
	ios_base::sync_with_stdio(false);
#endif

	int n, m, k;
	cin >> n >> m >> k;

	grav.resize(n);
	d.resize(n);
	was.resize(n);
	leaf.resize(n, true);
	par.resize(n);

	for (int i = 0; i < m; i++) {
		int u, v;
		cin >> u >> v;
		u--; v--;
		grav[u].push_back(v);
		grav[v].push_back(u);
	}

	dfs(0, -1);

	int l = 0;

	for (int i = 0; i < n; i++) {
		if (d[i] >= (n + k - 1) / k) {
			vector<int> path;

			while (i != 0) {
				path.push_back(i);
				for (int j : grav[i]) {
					if (d[j] == d[i] - 1) {
						i = j; break;
					}
				}
			}
			path.push_back(i);

			reverse(path.begin(), path.end());

			cout << "PATH" << endl;
			cout << path.size() << endl;
			for (int x : path)cout << x + 1 << " ";
			cout << endl;
			return 0;
		}
	}
	int c = 0;
	for (int i = 0; i < n; i++)dbg(i, grav[i]);

	printf("CYCLES\n");

	vector<int> cycle;
	for (int i = 0; i < n; i++) {
		if (leaf[i]) {
			cycle.clear();
			for (int j : grav[i]) {
				if ((d[i] - d[j]) % 3 != 2 && d[i] - d[j] != 1) {
					int x = i;
					while (x != j) {
						cycle.push_back(x);
						x = par[x];
					}
					cycle.push_back(x);
					break;
				}
			}
			if (cycle.empty()) {
				int u, v;
				for (int j : grav[i]) {
					if ((d[i] - d[j]) % 3 == 2) {
						if (u == -1) {
							u = j;
						}
						else if (v == -1) {
							v = j;
							break;
						}
					}
				}
				if (d[u] < d[v]) swap(u, v);
				while (u != v) {
					cycle.push_back(u);
					u = par[u];
				}
				cycle.push_back(u);
			}

			printf("%d\n", cycle.size());
			for (int x : cycle)printf("%d ", x + 1);
			printf("\n");
			c++;
			if (c == k)return 0;
		}
	}

#ifdef __ASD__
	auto finish_t = chrono::steady_clock::now();
	cerr << "Elapsed " << chrono::duration_cast<chrono::milliseconds>(finish_t - start_t).count() << " ms" << endl;
#endif
	return 0;
}


#pragma comment(linker, "/STACK:1677721600")

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <unordered_set>
#include <vector>
#include <memory.h>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <stdio.h>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <random>
#include <string>
#include <cassert>

using namespace std;

string to_string(string const &s) { return '"' + s + '"'; }
string to_string(char c) { return string(1, c); }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) { string s = "["; for (int qwe=0;qwe<v.size();qwe++) { s += to_string(v[qwe]) + ","; }s += "]"; return s; }
template <class T1, class T2>string to_string(pair<T1, T2> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <class T>string to_string(T c) { string s = "["; for (auto vvv : c) { s += to_string(vvv) + ","; }s += "]"; return s; }
void debug_impl() { cerr << endl; };
template <typename T1, typename... T2>void debug_impl(T1 a, T2... b) { cerr << " " << to_string(a); debug_impl(b...); }

#ifdef __ASD__
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_impl(__VA_ARGS__)
#else
#define dbg(...) ;
#endif
#define lng long long

vector<vector<int>> grav;
vector<int> d;
vector<bool> was;
vector<bool> leaf;
vector<int> par;

void dfs(int u, int p) {
	par[u]=p;
	d[u]=(p==-1)?1:d[p]+1;
	was[u]=true;
	for(int v:grav[u]) {
		if (v!=p&&!was[v]) {
			dfs(v, u);
			leaf[u]=false;
		}
	}
}

int main() {
#ifdef __ASD__
	freopen("input.txt", "r", stdin);
	//freopen("nul", "w", stderr);
	//freopen("output.txt", "w", stdout);
	auto start_t = chrono::steady_clock::now();
#else
	ios_base::sync_with_stdio(false);
#endif

	int n, m, k;
	cin >> n >> m >> k;

	grav.resize(n);
	d.resize(n);
	was.resize(n);
	leaf.resize(n, true);
	par.resize(n);

	for(int i=0;i<m;i++) {
		int u, v;
		cin >> u >> v;
		u--; v--;
		grav[u].push_back(v);
		grav[v].push_back(u);
	}

	dfs(0, -1);

	int l=0;

	for(int i=0;i<n;i++) {
		if (d[i]>=(n+k-1)/k) {
			vector<int> path;

			while (i!=0) {
				path.push_back(i);
				for(int j:grav[i]) {
					if (d[j]==d[i]-1) {
						i=j;break;
					}
				}
			}
			path.push_back(i);

			reverse(path.begin(), path.end());

			cout << "PATH" << endl;
			cout << path.size() << endl;
			for(int x:path)cout<<x+1<<" ";
			cout<< endl;
			return 0;
		}
	}
	int c=0;
	for(int i=0;i<n;i++)dbg(i, grav[i]);

	cout << "CYCLES" << endl;

	for(int i=0;i<n;i++) {
		if (leaf[i]) {
			vector<int> cycle;

			for(int j : grav[i]) {
				if ((d[i] - d[j])%3!=2 && d[i]-d[j]!=1) {
					int x = i;
					while (x!=j) {
						cycle.push_back(x);
						x=par[x];
					}
					cycle.push_back(x);
					break;
				}
			}
			if (cycle.empty()) {
				int u, v;
				for(int j : grav[i]) {
					if ((d[i] - d[j])%3==2) {
						if (u==-1) {
							u = j;
						} else if (v==-1) {
							v=j;
							break;
						}
					}
				}
				if (d[u] < d[v]) swap(u, v);
				while (u!=v) {
					cycle.push_back(u);
					u=par[u];
				}
				cycle.push_back(u);
			}

			cout << cycle.size() << endl;
			for(int x:cycle)cout<< x+1<<" ";
			cout << endl;
			c++;
			if (c==k)return 0;
		}
	}

#ifdef __ASD__
	auto finish_t = chrono::steady_clock::now();
	cerr << "Elapsed " << chrono::duration_cast<chrono::milliseconds>(finish_t - start_t).count() << " ms" << endl;
#endif
	return 0;
}


#pragma comment(linker, "/STACK:1677721600")

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <unordered_set>
#include <vector>
#include <memory.h>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <stdio.h>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <random>
#include <string>
#include <cassert>

using namespace std;

string to_string(string const &s) { return '"' + s + '"'; }
string to_string(char c) { return string(1, c); }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) { string s = "["; for (int qwe=0;qwe<v.size();qwe++) { s += to_string(v[qwe]) + ","; }s += "]"; return s; }
template <class T1, class T2>string to_string(pair<T1, T2> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <class T>string to_string(T c) { string s = "["; for (auto vvv : c) { s += to_string(vvv) + ","; }s += "]"; return s; }
void debug_impl() { cerr << endl; };
template <typename T1, typename... T2>void debug_impl(T1 a, T2... b) { cerr << " " << to_string(a); debug_impl(b...); }

#ifdef __ASD__
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_impl(__VA_ARGS__)
#else
#define dbg(...) ;
#endif
#define lng long long

vector<vector<int>> grav;
vector<int> d;
vector<bool> was;
vector<bool> leaf;

void dfs(int u, int p) {
	d[u]=(p==-1)?1:d[p]+1;
	was[u]=true;
	for(int v:grav[u]) {
		if (v!=p&&!was[v]) {
			dfs(v, u);
			leaf[u]=false;
		}
	}
}

int main() {
#ifdef __ASD__
	freopen("input.txt", "r", stdin);
	//freopen("nul", "w", stderr);
	//freopen("output.txt", "w", stdout);
	auto start_t = chrono::steady_clock::now();
#else
	ios_base::sync_with_stdio(false);
#endif

	int n, m, k;
	cin >> n >> m >> k;

	grav.resize(n);
	d.resize(n);
	was.resize(n);
	leaf.resize(n, true);

	for(int i=0;i<m;i++) {
		int u, v;
		cin >> u >> v;
		u--; v--;
		grav[u].push_back(v);
		grav[v].push_back(u);
	}

	dfs(0, -1);

	int l=0;

	for(int i=0;i<n;i++) {
		if (d[i]>=(n+k-1)/k) {
			vector<int> path;

			while (i!=0) {
				path.push_back(i);
				for(int j:grav[i]) {
					if (d[j]==d[i]-1) {
						i=j;break;
					}
				}
			}
			path.push_back(i);

			reverse(path.begin(), path.end());

			cout << "PATH" << endl;
			cout << path.size() << endl;
			for(int x:path)cout<<x+1<<" ";
			cout<< endl;
			return 0;
		}
	}
	int c=0;
	for(int i=0;i<n;i++)dbg(i, grav[i]);

	cout << "CYCLES" << endl;

	for(int i=0;i<n;i++) {
		if (leaf[i]) {
			vector<int> cycle;

			for(int j : grav[i]) {
				if ((d[i] - d[j])%3!=2 && d[i]-d[j]!=1) {
					int x = i;
					while (x!=j) {
						cycle.push_back(x);
						for(int y:grav[x])if(d[y]==d[x]-1){x=y;break;}
					}
					cycle.push_back(x);
					break;
				}
			}

			if (cycle.empty()) {
				int u=-1, v=-1;
				for(int j : grav[i]) {
					if (d[i] > d[j] && (d[i] - d[j])%3==2) {
						if (u==-1) {
							u = j;
						} else if (v==-1) {
							v = j;
							break;
						}
					}
				}
				if (d[u] < d[v]) swap(u, v);
				while (u!=v) {
					cycle.push_back(u);
					for(int y:grav[u])if(d[y]==d[u]-1){u=y;break;}
				}
				cycle.push_back(u);
				cycle.push_back(i);
			}

			cout << cycle.size() << endl;
			for(int x:cycle)cout<< x+1<<" ";
			cout << endl;
			c++;
			if (c==k)return 0;
		}
	}

#ifdef __ASD__
	auto finish_t = chrono::steady_clock::now();
	cerr << "Elapsed " << chrono::duration_cast<chrono::milliseconds>(finish_t - start_t).count() << " ms" << endl;
#endif
	return 0;
}


#pragma comment(linker, "/STACK:1677721600")

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <unordered_set>
#include <vector>
#include <memory.h>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <stdio.h>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <random>
#include <string>
#include <cassert>

using namespace std;

string to_string(string const &s) { return '"' + s + '"'; }
string to_string(char c) { return string(1, c); }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) { string s = "["; for (int qwe=0;qwe<v.size();qwe++) { s += to_string(v[qwe]) + ","; }s += "]"; return s; }
template <class T1, class T2>string to_string(pair<T1, T2> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <class T>string to_string(T c) { string s = "["; for (auto vvv : c) { s += to_string(vvv) + ","; }s += "]"; return s; }
void debug_impl() { cerr << endl; };
template <typename T1, typename... T2>void debug_impl(T1 a, T2... b) { cerr << " " << to_string(a); debug_impl(b...); }

#ifdef __ASD__
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_impl(__VA_ARGS__)
#else
#define dbg(...) ;
#endif
#define lng long long

vector<vector<int>> grav;
vector<int> d;
vector<bool> was;
vector<bool> leaf;

void dfs(int u, int p) {
	d[u]=(p==-1)?1:d[p]+1;
	was[u]=true;
	for(int v:grav[u]) {
		if (v!=p&&!was[v]) {
			dfs(v, u);
			leaf[u]=false;
		}
	}
}

int main() {
#ifdef __ASD__
	freopen("input.txt", "r", stdin);
	//freopen("nul", "w", stderr);
	//freopen("output.txt", "w", stdout);
	auto start_t = chrono::steady_clock::now();
#else
	ios_base::sync_with_stdio(false);
#endif

	int n, m, k;
	cin >> n >> m >> k;

	grav.resize(n);
	d.resize(n);
	was.resize(n);
	leaf.resize(n, true);

	for(int i=0;i<m;i++) {
		int u, v;
		cin >> u >> v;
		u--; v--;
		grav[u].push_back(v);
		grav[v].push_back(u);
	}

	dfs(0, -1);

	int l=0;

	for(int i=0;i<n;i++) {
		if (d[i]>=(n+k-1)/k) {
			vector<int> path;

			while (i!=0) {
				path.push_back(i);
				for(int j:grav[i]) {
					if (d[j]==d[i]-1) {
						i=j;break;
					}
				}
			}
			path.push_back(i);

			reverse(path.begin(), path.end());

			cout << "PATH" << endl;
			cout << path.size() << endl;
			for(int x:path)cout<<x+1<<" ";
			cout<< endl;
			return 0;
		}
	}
	int c=0;
	for(int i=0;i<n;i++)dbg(i, grav[i]);

	cout << "CYCLES" << endl;

	for(int i=0;i<n;i++) {
		if (leaf[i]) {
			vector<int> cycle;

			for(int j : grav[i]) {
				if ((d[i] - d[j])%3!=2 && d[i]-d[j]!=1) {
					int x = i;
					while (x!=j) {
						cycle.push_back(x);
						for(int y:grav[x])if(d[y]==d[x]-1){x=y;break;}
					}
					cycle.push_back(x);
					break;
				}
			}
			if (cycle.empty()) {
				int u=-1, v=-1;
				for(int j : grav[i]) {
					if (d[i]>d[j]&& (d[i] - d[j])%3==2) {
						if (u==-1) {
							u = j;
						} else if (v==-1) {
							v = j;
							break;
						}
					}
				}
				if (d[u] < d[v]) swap(u, v);
				while (u!=v) {
					cycle.push_back(u);
					for(int y:grav[u])if(d[y]==d[u]-1){u=y;break;}
				}
				cycle.push_back(u);
			}

			cout << cycle.size() << endl;
			for(int x:cycle)cout<< x+1<<" ";
			cout << endl;
			c++;
			if (c==k)return 0;
		}
	}

#ifdef __ASD__
	auto finish_t = chrono::steady_clock::now();
	cerr << "Elapsed " << chrono::duration_cast<chrono::milliseconds>(finish_t - start_t).count() << " ms" << endl;
#endif
	return 0;
}


#pragma comment(linker, "/STACK:1677721600")

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <unordered_set>
#include <vector>
#include <memory.h>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <stdio.h>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <random>
#include <string>
#include <cassert>

using namespace std;

string to_string(string const &s) { return '"' + s + '"'; }
string to_string(char c) { return string(1, c); }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) { string s = "["; for (int qwe=0;qwe<v.size();qwe++) { s += to_string(v[qwe]) + ","; }s += "]"; return s; }
template <class T1, class T2>string to_string(pair<T1, T2> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <class T>string to_string(T c) { string s = "["; for (auto vvv : c) { s += to_string(vvv) + ","; }s += "]"; return s; }
void debug_impl() { cerr << endl; };
template <typename T1, typename... T2>void debug_impl(T1 a, T2... b) { cerr << " " << to_string(a); debug_impl(b...); }

#ifdef __ASD__
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_impl(__VA_ARGS__)
#else
#define dbg(...) ;
#endif
#define lng long long

vector<vector<int>> grav;
vector<int> d;
vector<bool> was;
vector<bool> leaf;

void dfs(int u, int p) {
	d[u]=(p==-1)?1:d[p]+1;
	was[u]=true;
	for(int v:grav[u]) {
		if (v!=p&&!was[v]) {
			dfs(v, u);
			leaf[u]=false;
		}
	}
}

int main() {
#ifdef __ASD__
	freopen("input.txt", "r", stdin);
	//freopen("nul", "w", stderr);
	//freopen("output.txt", "w", stdout);
	auto start_t = chrono::steady_clock::now();
#else
	ios_base::sync_with_stdio(false);
#endif

	int n, m, k;
	cin >> n >> m >> k;

	grav.resize(n);
	d.resize(n);
	was.resize(n);
	leaf.resize(n, true);

	for(int i=0;i<m;i++) {
		int u, v;
		cin >> u >> v;
		u--; v--;
		grav[u].push_back(v);
		grav[v].push_back(u);
	}

	dfs(0, -1);

	int l=0;

	for(int i=0;i<n;i++) {
		if (d[i]>=(n+k-1)/k) {
			vector<int> path;

			while (i!=0) {
				path.push_back(i);
				for(int j:grav[i]) {
					if (d[j]==d[i]-1) {
						i=j;break;
					}
				}
			}
			path.push_back(i);

			reverse(path.begin(), path.end());

			cout << "PATH" << endl;
			cout << path.size() << endl;
			for(int x:path)cout<<x+1<<" ";
			cout<< endl;
			return 0;
		}
	}
	int c=0;
	for(int i=0;i<n;i++)dbg(i, grav[i]);

	cout << "CYCLES" << endl;

	for(int i=0;i<n;i++) {
		if (leaf[i]) {
			vector<int> cycle;

			for(int j : grav[i]) {
				if ((d[i] - d[j])%3!=2 && d[i]-d[j]!=1) {
					int x = i;
					while (x!=j) {
						cycle.push_back(x);
						for(int y:grav[x])if(d[y]==d[x]-1){x=y;break;}
					}
					cycle.push_back(x);
					break;
				}
			}
			if (cycle.empty()) {
				int u, v;
				for(int j : grav[i]) {
					if ((d[i] - d[j])%3==2) {
						if (u==-1) {
							u = j;
						} else if (v==-1) {
							v=j;
							break;
						}
					}
				}
				if (d[u] < d[v]) swap(u, v);
				while (u!=v) {
					cycle.push_back(u);
					for(int y:grav[u])if(d[y]==d[u]-1){u=y;break;}
				}
				cycle.push_back(u);
			}

			cout << cycle.size() << endl;
			for(int x:cycle)cout<< x+1<<" ";
			cout << endl;
			c++;
			if (c==k)return 0;
		}
	}

#ifdef __ASD__
	auto finish_t = chrono::steady_clock::now();
	cerr << "Elapsed " << chrono::duration_cast<chrono::milliseconds>(finish_t - start_t).count() << " ms" << endl;
#endif
	return 0;
}


#pragma comment(linker, "/STACK:1677721600")

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <unordered_set>
#include <vector>
#include <memory.h>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <stdio.h>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <random>
#include <string>
#include <cassert>

using namespace std;

string to_string(string const &s) { return '"' + s + '"'; }
string to_string(char c) { return string(1, c); }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) { string s = "["; for (int qwe=0;qwe<v.size();qwe++) { s += to_string(v[qwe]) + ","; }s += "]"; return s; }
template <class T1, class T2>string to_string(pair<T1, T2> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <class T>string to_string(T c) { string s = "["; for (auto vvv : c) { s += to_string(vvv) + ","; }s += "]"; return s; }
void debug_impl() { cerr << endl; };
template <typename T1, typename... T2>void debug_impl(T1 a, T2... b) { cerr << " " << to_string(a); debug_impl(b...); }

#ifdef __ASD__
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_impl(__VA_ARGS__)
#else
#define dbg(...) ;
#endif
#define lng long long

vector<vector<int>> grav;
vector<int> d;
vector<bool> was;
vector<bool> leaf;

void dfs(int u, int p) {
	d[u]=(p==-1)?1:d[p]+1;
	was[u]=true;
	for(int v:grav[u]) {
		if (v!=p&&!was[v]) {
			dfs(v, u);
			leaf[u]=false;
		}
	}
}

int main() {
#ifdef __ASD__
	freopen("input.txt", "r", stdin);
	//freopen("nul", "w", stderr);
	//freopen("output.txt", "w", stdout);
	auto start_t = chrono::steady_clock::now();
#else
	ios_base::sync_with_stdio(false);
#endif

	int n, m, k;
	cin >> n >> m >> k;

	grav.resize(n);
	d.resize(n);
	was.resize(n);
	leaf.resize(n, true);

	for(int i=0;i<m;i++) {
		int u, v;
		cin >> u >> v;
		u--; v--;
		grav[u].push_back(v);
		grav[v].push_back(u);
	}

	dfs(0, -1);

	int l=0;

	for(int i=0;i<n;i++) {
		if (d[i]>=(n+k-1)/k) {
			vector<int> path;

			while (i!=0) {
				path.push_back(i);
				for(int j:grav[i]) {
					if (j==0||d[j]==d[i]-1) {
						i=j;break;
					}
				}
			}
			path.push_back(i);

			reverse(path.begin(), path.end());

			cout << "PATH" << endl;
			cout << path.size() << endl;
			for(int x:path)cout<<x+1<<" ";
			cout<< endl;
			return 0;
		}
	}

	for(int i=0;i<n;i++)dbg(i, grav[i]);

	cout << "CYCLES" << endl;

	for(int i=0;i<n;i++) {
		if (leaf[i]) {
			vector<int> cycle;

			for(int j : grav[i]) {
				if ((d[i] - d[j])%3!=2) {
					int x = i;
					while (x!=j) {
						cycle.push_back(x);
						for(int y:grav[x])if(d[y]==d[x]-1){x=y;break;}
					}
					cycle.push_back(x);
					break;
				}
			}
			if (cycle.empty()) {
				int u, v;
				for(int j : grav[i]) {
					if ((d[i] - d[j])%3==2) {
						if (u==-1) {
							u = j;
						} else if (v==-1) {
							v=j;
							break;
						}
					}
				}
				if (d[u] < d[v]) swap(u, v);
				while (u!=v) {
					cycle.push_back(u);
					for(int y:grav[u])if(d[y]==d[u]-1){u=y;break;}
				}
				cycle.push_back(u);
			}

			cout << cycle.size();
			for(int x:cycle)cout<<" " << x+1;
			cout << endl;
		}
	}

#ifdef __ASD__
	auto finish_t = chrono::steady_clock::now();
	cerr << "Elapsed " << chrono::duration_cast<chrono::milliseconds>(finish_t - start_t).count() << " ms" << endl;
#endif
	return 0;
}


#pragma comment(linker, "/STACK:1677721600")

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <unordered_set>
#include <vector>
#include <memory.h>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <stdio.h>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <random>
#include <string>
#include <cassert>

using namespace std;

string to_string(string const &s) { return '"' + s + '"'; }
string to_string(char c) { return string(1, c); }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) { string s = "["; for (int qwe=0;qwe<v.size();qwe++) { s += to_string(v[qwe]) + ","; }s += "]"; return s; }
template <class T1, class T2>string to_string(pair<T1, T2> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <class T>string to_string(T c) { string s = "["; for (auto vvv : c) { s += to_string(vvv) + ","; }s += "]"; return s; }
void debug_impl() { cerr << endl; };
template <typename T1, typename... T2>void debug_impl(T1 a, T2... b) { cerr << " " << to_string(a); debug_impl(b...); }

#ifdef __ASD__
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_impl(__VA_ARGS__)
#else
#define dbg(...) ;
#endif
#define lng long long

vector<vector<int>> grav;
vector<int> d;
vector<bool> was;
vector<bool> leaf;

void dfs(int u, int p) {
	d[u]=(p==-1)?1:d[p]+1;
	was[u]=true;
	for(int v:grav[u]) {
		if (v!=p&&!was[v]) {
			dfs(v, u);
			leaf[u]=false;
		}
	}
}

int main() {
#ifdef __ASD__
	freopen("input.txt", "r", stdin);
	//freopen("nul", "w", stderr);
	//freopen("output.txt", "w", stdout);
	auto start_t = chrono::steady_clock::now();
#else
	ios_base::sync_with_stdio(false);
#endif

	int n, m, k;
	cin >> n >> m >> k;

	grav.resize(n);
	d.resize(n);
	was.resize(n);
	leaf.resize(n, true);

	for(int i=0;i<m;i++) {
		int u, v;
		cin >> u >> v;
		u--; v--;
		grav[u].push_back(v);
		grav[v].push_back(u);
	}

	dfs(0, -1);

	int l=0;

	for(int i=0;i<n;i++) {
		if (d[i]>=(n+k-1)/k) {
			vector<int> path;

			while (i!=0) {
				path.push_back(i);
				for(int j:grav[i]) {
					if (d[j]==d[i]-1) {
						i=j;break;
					}
				}
			}
			path.push_back(i);

			reverse(path.begin(), path.end());

			cout << "PATH" << endl;
			cout << path.size() << endl;
			for(int x:path)cout<<x+1<<" ";
			cout<< endl;
			return 0;
		}
	}
	int c=0;
	for(int i=0;i<n;i++)dbg(i, grav[i]);

	cout << "CYCLES" << endl;

	for(int i=0;i<n;i++) {
		if (leaf[i]) {
			vector<int> cycle;

			for(int j : grav[i]) {
				if ((d[i] - d[j])%3!=2 && d[i]-d[j]!=1) {
					int x = i;
					while (x!=j) {
						cycle.push_back(x);
						for(int y:grav[x])if(d[y]==d[x]-1){x=y;break;}
					}
					cycle.push_back(x);
					break;
				}
			}
			if (cycle.empty()) {
				int u=-1, v=-1;
				for(int j : grav[i]) {
					if ((d[i] - d[j])%3==2) {
						if (u==-1) {
							u = j;
						} else if (v==-1) {
							v=j;
							break;
						}
					}
				}
				if (d[u] < d[v]) swap(u, v);
				while (u!=v) {
					cycle.push_back(u);
					for(int y:grav[u])if(d[y]==d[u]-1){u=y;break;}
				}
				cycle.push_back(u);
			}

			cout << cycle.size() << endl;
			for(int x:cycle)cout<< x+1<<" ";
			cout << endl;
			c++;
			if (c==k)return 0;
		}
	}

#ifdef __ASD__
	auto finish_t = chrono::steady_clock::now();
	cerr << "Elapsed " << chrono::duration_cast<chrono::milliseconds>(finish_t - start_t).count() << " ms" << endl;
#endif
	return 0;
}


#pragma comment(linker, "/STACK:1677721600")

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <unordered_set>
#include <vector>
#include <memory.h>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <stdio.h>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <random>
#include <string>
#include <cassert>

using namespace std;

string to_string(string const &s) { return '"' + s + '"'; }
string to_string(char c) { return string(1, c); }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) { string s = "["; for (int qwe=0;qwe<v.size();qwe++) { s += to_string(v[qwe]) + ","; }s += "]"; return s; }
template <class T1, class T2>string to_string(pair<T1, T2> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <class T>string to_string(T c) { string s = "["; for (auto vvv : c) { s += to_string(vvv) + ","; }s += "]"; return s; }
void debug_impl() { cerr << endl; };
template <typename T1, typename... T2>void debug_impl(T1 a, T2... b) { cerr << " " << to_string(a); debug_impl(b...); }

#ifdef __ASD__
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_impl(__VA_ARGS__)
#else
#define dbg(...) ;
#endif
#define lng long long

vector<vector<int>> grav;
vector<int> d;
vector<bool> was;
vector<bool> leaf;

void dfs(int u, int p) {
	d[u]=(p==-1)?1:d[p]+1;
	was[u]=true;
	for(int v:grav[u]) {
		if (v!=p&&!was[v]) {
			dfs(v, u);
			leaf[u]=false;
		}
	}
}

int main() {
#ifdef __ASD__
	freopen("input.txt", "r", stdin);
	//freopen("nul", "w", stderr);
	//freopen("output.txt", "w", stdout);
	auto start_t = chrono::steady_clock::now();
#else
	ios_base::sync_with_stdio(false);
#endif

	int n, m, k;
	cin >> n >> m >> k;

	grav.resize(n);
	d.resize(n);
	was.resize(n);
	leaf.resize(n, true);

	for(int i=0;i<m;i++) {
		int u, v;
		cin >> u >> v;
		u--; v--;
		grav[u].push_back(v);
		grav[v].push_back(u);
	}

	dfs(0, -1);

	int l=0;

	for(int i=0;i<n;i++) {
		if (d[i]>=(n+k-1)/k) {
			vector<int> path;

			while (i!=0) {
				path.push_back(i);
				for(int j:grav[i]) {
					if (j==0||d[j]==d[i]-1) {
						i=j;break;
					}
				}
			}
			path.push_back(i);

			reverse(path.begin(), path.end());

			cout << "PATH" << endl;
			cout << path.size() << endl;
			for(int x:path)cout<<x+1<<" ";
			cout<< endl;
			return 0;
		}
	}
	int c=0;
	for(int i=0;i<n;i++)dbg(i, grav[i]);

	cout << "CYCLES" << endl;

	for(int i=0;i<n;i++) {
		if (leaf[i]) {
			vector<int> cycle;

			for(int j : grav[i]) {
				if ((d[i] - d[j])%3!=2) {
					int x = i;
					while (x!=j) {
						cycle.push_back(x);
						for(int y:grav[x])if(d[y]==d[x]-1){x=y;break;}
					}
					cycle.push_back(x);
					break;
				}
			}
			if (cycle.empty()) {
				int u, v;
				for(int j : grav[i]) {
					if ((d[i] - d[j])%3==2) {
						if (u==-1) {
							u = j;
						} else if (v==-1) {
							v=j;
							break;
						}
					}
				}
				if (d[u] < d[v]) swap(u, v);
				while (u!=v) {
					cycle.push_back(u);
					for(int y:grav[u])if(d[y]==d[u]-1){u=y;break;}
				}
				cycle.push_back(u);
			}

			cout << cycle.size() << endl;
			for(int x:cycle)cout<<" " << x+1;
			cout << endl;
			c++;
			if (c==k)return 0;
		}
	}

#ifdef __ASD__
	auto finish_t = chrono::steady_clock::now();
	cerr << "Elapsed " << chrono::duration_cast<chrono::milliseconds>(finish_t - start_t).count() << " ms" << endl;
#endif
	return 0;
}


#pragma comment(linker, "/STACK:1677721600")

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <unordered_set>
#include <vector>
#include <memory.h>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <stdio.h>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <random>
#include <string>
#include <cassert>

using namespace std;

string to_string(string const &s) { return '"' + s + '"'; }
string to_string(char c) { return string(1, c); }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) { string s = "["; for (int qwe=0;qwe<v.size();qwe++) { s += to_string(v[qwe]) + ","; }s += "]"; return s; }
template <class T1, class T2>string to_string(pair<T1, T2> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <class T>string to_string(T c) { string s = "["; for (auto vvv : c) { s += to_string(vvv) + ","; }s += "]"; return s; }
void debug_impl() { cerr << endl; };
template <typename T1, typename... T2>void debug_impl(T1 a, T2... b) { cerr << " " << to_string(a); debug_impl(b...); }

#ifdef __ASD__
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_impl(__VA_ARGS__)
#else
#define dbg(...) ;
#endif
#define lng long long

vector<vector<int>> grav;
vector<int> d;
vector<bool> was;
vector<bool> leaf;
vector<int> par;

void dfs(int u, int p) {
	par[u]=p;
	d[u]=(p==-1)?1:d[p]+1;
	was[u]=true;
	for(int v:grav[u]) {
		if (v!=p&&!was[v]) {
			dfs(v, u);
			leaf[u]=false;
		}
	}
}

int main() {
#ifdef __ASD__
	freopen("input.txt", "r", stdin);
	//freopen("nul", "w", stderr);
	//freopen("output.txt", "w", stdout);
	auto start_t = chrono::steady_clock::now();
#else
	ios_base::sync_with_stdio(false);
#endif

	int n, m, k;
	cin >> n >> m >> k;

	grav.resize(n);
	d.resize(n);
	was.resize(n);
	leaf.resize(n, true);
	par.resize(n);

	for(int i=0;i<m;i++) {
		int u, v;
		cin >> u >> v;
		u--; v--;
		grav[u].push_back(v);
		grav[v].push_back(u);
	}

	dfs(0, -1);

	int l=0;

	for(int i=0;i<n;i++) {
		if (d[i]>=(n+k-1)/k) {
			vector<int> path;

			while (i!=0) {
				path.push_back(i);
				for(int j:grav[i]) {
					if (d[j]==d[i]-1) {
						i=j;break;
					}
				}
			}
			path.push_back(i);

			reverse(path.begin(), path.end());

			cout << "PATH" << endl;
			cout << path.size() << endl;
			for(int x:path)cout<<x+1<<" ";
			cout<< endl;
			return 0;
		}
	}
	int c=0;
	for(int i=0;i<n;i++)dbg(i, grav[i]);

	printf("CYCLES\n");

	for(int i=0;i<n;i++) {
		if (leaf[i]) {
			vector<int> cycle;

			for(int j : grav[i]) {
				if ((d[i] - d[j])%3!=2 && d[i]-d[j]!=1) {
					int x = i;
					while (x!=j) {
						cycle.push_back(x);
						x=par[x];
					}
					cycle.push_back(x);
					break;
				}
			}
			if (cycle.empty()) {
				int u, v;
				for(int j : grav[i]) {
					if ((d[i] - d[j])%3==2) {
						if (u==-1) {
							u = j;
						} else if (v==-1) {
							v=j;
							break;
						}
					}
				}
				if (d[u] < d[v]) swap(u, v);
				while (u!=v) {
					cycle.push_back(u);
					u=par[u];
				}
				cycle.push_back(u);
			}

			printf("%d\n", cycle.size());
			for(int x:cycle)printf("%d ", x+1);
			printf("\n");
			c++;
			if (c==k)return 0;
		}
	}

#ifdef __ASD__
	auto finish_t = chrono::steady_clock::now();
	cerr << "Elapsed " << chrono::duration_cast<chrono::milliseconds>(finish_t - start_t).count() << " ms" << endl;
#endif
	return 0;
}


#pragma comment(linker, "/STACK:1677721600")

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <unordered_set>
#include <vector>
#include <memory.h>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <stdio.h>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <random>
#include <string>
#include <cassert>

using namespace std;

string to_string(string const &s) { return '"' + s + '"'; }
string to_string(char c) { return string(1, c); }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) { string s = "["; for (int qwe = 0; qwe < v.size(); qwe++) { s += to_string(v[qwe]) + ","; }s += "]"; return s; }
template <class T1, class T2>string to_string(pair<T1, T2> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <class T>string to_string(T c) { string s = "["; for (auto vvv : c) { s += to_string(vvv) + ","; }s += "]"; return s; }
void debug_impl() { cerr << endl; };
template <typename T1, typename... T2>void debug_impl(T1 a, T2... b) { cerr << " " << to_string(a); debug_impl(b...); }

#ifdef __ASD__
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_impl(__VA_ARGS__)
#else
#define dbg(...) ;
#endif
#define lng long long

vector<vector<int>> grav;
vector<int> d;
vector<bool> was;
vector<bool> leaf;
vector<int> par;

void dfs(int u, int p) {
	par[u] = p;
	d[u] = (p == -1) ? 1 : d[p] + 1;
	was[u] = true;
	for (int v : grav[u]) {
		if (v != p && !was[v]) {
			dfs(v, u);
			leaf[u] = false;
		}
	}
}

int main() {
#ifdef __ASD__
	freopen("input.txt", "r", stdin);
	//freopen("nul", "w", stderr);
	//freopen("output.txt", "w", stdout);
	auto start_t = chrono::steady_clock::now();
#else
	ios_base::sync_with_stdio(false);
#endif

	int n, m, k;
	cin >> n >> m >> k;

	grav.resize(n);
	d.resize(n);
	was.resize(n);
	leaf.resize(n, true);
	par.resize(n);

	for (int i = 0; i < m; i++) {
		int u, v;
		cin >> u >> v;
		u--; v--;
		grav[u].push_back(v);
		grav[v].push_back(u);
	}

	dfs(0, -1);

	int l = 0;

	for (int i = 0; i < n; i++) {
		if (d[i] >= (n + k - 1) / k) {
			vector<int> path;

			while (i != 0) {
				path.push_back(i);
				for (int j : grav[i]) {
					if (d[j] == d[i] - 1) {
						i = j; break;
					}
				}
			}
			path.push_back(i);

			reverse(path.begin(), path.end());

			cout << "PATH" << endl;
			cout << path.size() << endl;
			for (int x : path)cout << x + 1 << " ";
			cout << endl;
			return 0;
		}
	}
	int c = 0;
	for (int i = 0; i < n; i++)dbg(i, grav[i]);

	printf("CYCLES\n");

	vector<int> cycle;
	for (int i = 0; i < n; i++) {
		if (leaf[i]) {
			cycle.clear();
			for (int j : grav[i]) {
				if ((d[i] - d[j]) % 3 != 2 && d[i] - d[j] != 1) {
					int x = i;
					while (x != j) {
						cycle.push_back(x);
						x = par[x];
					}
					cycle.push_back(x);
					break;
				}
			}
			if (cycle.empty()) {
				int u=-1, v=-1;
				for (int j : grav[i]) {
					if ((d[i] - d[j]) % 3 == 2) {
						if (u == -1) {
							u = j;
						}
						else if (v == -1) {
							v = j;
							break;
						}
					}
				}
				if (d[u] < d[v]) swap(u, v);
				while (u != v) {
					if (u==-1)return 100;
					cycle.push_back(u);
					u = par[u];
				}
				cycle.push_back(u);
			}

			printf("%d\n", cycle.size());
			for (int x : cycle)printf("%d ", x + 1);
			printf("\n");
			c++;
			if (c == k)return 0;
		}
	}

#ifdef __ASD__
	auto finish_t = chrono::steady_clock::now();
	cerr << "Elapsed " << chrono::duration_cast<chrono::milliseconds>(finish_t - start_t).count() << " ms" << endl;
#endif
	return 0;
}


#pragma comment(linker, "/STACK:1677721600")

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <unordered_set>
#include <vector>
#include <memory.h>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <stdio.h>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <random>
#include <string>
#include <cassert>

using namespace std;

string to_string(string const &s) { return '"' + s + '"'; }
string to_string(char c) { return string(1, c); }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) { string s = "["; for (int qwe = 0; qwe < v.size(); qwe++) { s += to_string(v[qwe]) + ","; }s += "]"; return s; }
template <class T1, class T2>string to_string(pair<T1, T2> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <class T>string to_string(T c) { string s = "["; for (auto vvv : c) { s += to_string(vvv) + ","; }s += "]"; return s; }
void debug_impl() { cerr << endl; };
template <typename T1, typename... T2>void debug_impl(T1 a, T2... b) { cerr << " " << to_string(a); debug_impl(b...); }

#ifdef __ASD__
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_impl(__VA_ARGS__)
#else
#define dbg(...) ;
#endif
#define lng long long

vector<vector<int>> grav;
vector<int> d;
vector<bool> was;
vector<bool> leaf;
vector<int> par;

void dfs(int u, int p) {
	par[u] = p;
	d[u] = (p == -1) ? 1 : d[p] + 1;
	was[u] = true;
	for (int v : grav[u]) {
		if (v != p && !was[v]) {
			dfs(v, u);
			leaf[u] = false;
		}
	}
}

int main() {
#ifdef __ASD__
	freopen("input.txt", "r", stdin);
	//freopen("nul", "w", stderr);
	//freopen("output.txt", "w", stdout);
	auto start_t = chrono::steady_clock::now();
#else
	ios_base::sync_with_stdio(false);
#endif

	int n, m, k;
	cin >> n >> m >> k;

	grav.resize(n);
	d.resize(n);
	was.resize(n);
	leaf.resize(n, true);
	par.resize(n);

	for (int i = 0; i < m; i++) {
		int u, v;
		cin >> u >> v;
		u--; v--;
		grav[u].push_back(v);
		grav[v].push_back(u);
	}

	dfs(0, -1);

	int l = 0;

	for (int i = 0; i < n; i++) {
		if (d[i] >= (n + k - 1) / k) {
			vector<int> path;

			while (i != 0) {
				path.push_back(i);
				for (int j : grav[i]) {
					if (d[j] == d[i] - 1) {
						i = j; break;
					}
				}
			}
			path.push_back(i);

			reverse(path.begin(), path.end());

			cout << "PATH" << endl;
			cout << path.size() << endl;
			for (int x : path)cout << x + 1 << " ";
			cout << endl;
			return 0;
		}
	}
	int c = 0;
	for (int i = 0; i < n; i++)dbg(i, grav[i]);

	printf("CYCLES\n");

	vector<int> cycle;
	for (int i = 0; i < n; i++) {
		if (leaf[i]) {
			cycle.clear();
			for (int j : grav[i]) {
				if ((d[i] - d[j]) % 3 != 2 && d[i] - d[j] != 1) {
					int x = i;
					while (x != j) {
						cycle.push_back(x);
						x = par[x];
					}
					cycle.push_back(x);
					break;
				}
			}
			if (cycle.empty()) {
				int u, v;
				for (int j : grav[i]) {
					if ((d[i] - d[j]) % 3 == 2) {
						if (u == -1) {
							u = j;
						}
						else if (v == -1) {
							v = j;
							break;
						}
					}
				}
				if (d[u] < d[v]) swap(u, v);
				while (u != v) {
					if (u==-1)return 100;
					cycle.push_back(u);
					u = par[u];
				}
				cycle.push_back(u);
			}

			printf("%d\n", cycle.size());
			for (int x : cycle)printf("%d ", x + 1);
			printf("\n");
			c++;
			if (c == k)return 0;
		}
	}

#ifdef __ASD__
	auto finish_t = chrono::steady_clock::now();
	cerr << "Elapsed " << chrono::duration_cast<chrono::milliseconds>(finish_t - start_t).count() << " ms" << endl;
#endif
	return 0;
}


#pragma comment(linker, "/STACK:1677721600")

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <unordered_set>
#include <vector>
#include <memory.h>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <stdio.h>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <random>
#include <string>
#include <cassert>

using namespace std;

string to_string(string const &s) { return '"' + s + '"'; }
string to_string(char c) { return string(1, c); }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) { string s = "["; for (int qwe=0;qwe<v.size();qwe++) { s += to_string(v[qwe]) + ","; }s += "]"; return s; }
template <class T1, class T2>string to_string(pair<T1, T2> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <class T>string to_string(T c) { string s = "["; for (auto vvv : c) { s += to_string(vvv) + ","; }s += "]"; return s; }
void debug_impl() { cerr << endl; };
template <typename T1, typename... T2>void debug_impl(T1 a, T2... b) { cerr << " " << to_string(a); debug_impl(b...); }

#ifdef __ASD__
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_impl(__VA_ARGS__)
#else
#define dbg(...) ;
#endif
#define lng long long

vector<vector<int>> grav;
vector<int> d;
vector<bool> was;
vector<bool> leaf;

void dfs(int u, int p) {
	d[u]=(p==-1)?1:d[p]+1;
	was[u]=true;
	for(int v:grav[u]) {
		if (v!=p&&!was[v]) {
			dfs(v, u);
			leaf[u]=false;
		}
	}
}

int main() {
#ifdef __ASD__
	freopen("input.txt", "r", stdin);
	//freopen("nul", "w", stderr);
	//freopen("output.txt", "w", stdout);
	auto start_t = chrono::steady_clock::now();
#else
	ios_base::sync_with_stdio(false);
#endif

	int n, m, k;
	cin >> n >> m >> k;

	grav.resize(n);
	d.resize(n);
	was.resize(n);
	leaf.resize(n, true);

	for(int i=0;i<m;i++) {
		int u, v;
		cin >> u >> v;
		u--; v--;
		grav[u].push_back(v);
		grav[v].push_back(u);
	}

	dfs(0, -1);

	int l=0;

	for(int i=0;i<n;i++) {
		if (d[i]>=(n+k-1)/k) {
			vector<int> path;

			while (i!=0) {
				path.push_back(i);
				for(int j:grav[i]) {
					if (j==0||d[j]==d[i]-1) {
						i=j;break;
					}
				}
			}
			path.push_back(i);

			reverse(path.begin(), path.end());

			cout << "PATH" << endl;
			cout << path.size() << endl;
			for(int x:path)cout<<x+1<<" ";
			cout<< endl;
			return 0;
		}
	}
	int c=0;
	for(int i=0;i<n;i++)dbg(i, grav[i]);

	cout << "CYCLES" << endl;

	for(int i=0;i<n;i++) {
		if (leaf[i]) {
			vector<int> cycle;

			for(int j : grav[i]) {
				if ((d[i] - d[j])%3!=2) {
					int x = i;
					while (x!=j) {
						cycle.push_back(x);
						for(int y:grav[x])if(d[y]==d[x]-1){x=y;break;}
					}
					cycle.push_back(x);
					break;
				}
			}
			if (cycle.empty()) {
				int u, v;
				for(int j : grav[i]) {
					if ((d[i] - d[j])%3==2) {
						if (u==-1) {
							u = j;
						} else if (v==-1) {
							v=j;
							break;
						}
					}
				}
				if (d[u] < d[v]) swap(u, v);
				while (u!=v) {
					cycle.push_back(u);
					for(int y:grav[u])if(d[y]==d[u]-1){u=y;break;}
				}
				cycle.push_back(u);
			}

			cout << cycle.size() << endl;
			for(int x:cycle)cout<<" " << x+1;
			cout << endl;
			c++;
			if (c==k)return;
		}
	}

#ifdef __ASD__
	auto finish_t = chrono::steady_clock::now();
	cerr << "Elapsed " << chrono::duration_cast<chrono::milliseconds>(finish_t - start_t).count() << " ms" << endl;
#endif
	return 0;
}


#pragma comment(linker, "/STACK:1677721600")

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <unordered_set>
#include <vector>
#include <memory.h>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <stdio.h>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <random>
#include <string>
#include <cassert>

using namespace std;

string to_string(string const &s) { return '"' + s + '"'; }
string to_string(char c) { return string(1, c); }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) { string s = "["; for (int qwe=0;qwe<v.size();qwe++) { s += to_string(v[qwe]) + ","; }s += "]"; return s; }
template <class T1, class T2>string to_string(pair<T1, T2> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <class T>string to_string(T c) { string s = "["; for (auto vvv : c) { s += to_string(vvv) + ","; }s += "]"; return s; }
void debug_impl() { cerr << endl; };
template <typename T1, typename... T2>void debug_impl(T1 a, T2... b) { cerr << " " << to_string(a); debug_impl(b...); }

#ifdef __ASD__
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_impl(__VA_ARGS__)
#else
#define dbg(...) ;
#endif
#define lng long long

vector<vector<int>> grav;
vector<int> d;
vector<bool> was;
vector<bool> leaf;

void dfs(int u, int p) {
	d[u]=(p==-1)?1:d[p]+1;
	was[u]=true;
	for(int v:grav[u]) {
		if (v!=p&&!was[v]) {
			dfs(v, u);
			leaf[u]=false;
		}
	}
}

int main() {
#ifdef __ASD__
	freopen("input.txt", "r", stdin);
	//freopen("nul", "w", stderr);
	//freopen("output.txt", "w", stdout);
	auto start_t = chrono::steady_clock::now();
#else
	ios_base::sync_with_stdio(false);
#endif

	int n, m, k;
	cin >> n >> m >> k;

	grav.resize(n);
	d.resize(n);
	was.resize(n);
	leaf.resize(n, true);

	for(int i=0;i<m;i++) {
		int u, v;
		cin >> u >> v;
		u--; v--;
		grav[u].push_back(v);
		grav[v].push_back(u);
	}

	dfs(0, -1);

	int l=0;

	for(int i=0;i<n;i++) {
		if (d[i]>=(n+k-1)/k) {
			vector<int> path;

			while (i!=0) {
				path.push_back(i);
				for(int j:grav[i]) {
					if (j==0||d[j]==d[i]-1) {
						i=j;break;
					}
				}
			}
			path.push_back(i);

			reverse(path.begin(), path.end());

			cout << "PATH" << endl;
			cout << path.size() << endl;
			for(int x:path)cout<<x+1<<" ";
			cout<< endl;
			return 0;
		}
		if (leaf[i])l++;
	}

	for(int i=0;i<n;i++)dbg(i, grav[i]);

	cout << "CYCLES" << endl;
	cout << l << endl;

	for(int i=0;i<n;i++) {
		if (leaf[i]) {
			vector<int> cycle;

			for(int j : grav[i]) {
				if ((d[i] - d[j])%3!=2) {
					int x = i;
					while (x!=j) {
						cycle.push_back(x);
						for(int y:grav[x])if(d[y]==d[x]-1){x=y;break;}
					}
					cycle.push_back(x);
					break;
				}
			}
			if (cycle.empty()) {
				int u, v;
				for(int j : grav[i]) {
					if ((d[i] - d[j])%3==2) {
						if (u==-1) {
							u = j;
						} else if (v==-1) {
							v=j;
							break;
						}
					}
				}
				if (d[u] < d[v]) swap(u, v);
				while (u!=v) {
					cycle.push_back(u);
					for(int y:grav[u])if(d[y]==d[u]-1){u=y;break;}
				}
				cycle.push_back(u);
			}

			cout << cycle.size();
			for(int x:cycle)cout<<" " << x+1;
			cout << endl;
		}
	}

#ifdef __ASD__
	auto finish_t = chrono::steady_clock::now();
	cerr << "Elapsed " << chrono::duration_cast<chrono::milliseconds>(finish_t - start_t).count() << " ms" << endl;
#endif
	return 0;
}


#pragma comment(linker, "/STACK:1677721600")

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <unordered_set>
#include <vector>
#include <memory.h>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <stdio.h>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <random>
#include <string>
#include <cassert>

using namespace std;

string to_string(string const &s) { return '"' + s + '"'; }
string to_string(char c) { return string(1, c); }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) { string s = "["; for (int qwe=0;qwe<v.size();qwe++) { s += to_string(v[qwe]) + ","; }s += "]"; return s; }
template <class T1, class T2>string to_string(pair<T1, T2> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <class T>string to_string(T c) { string s = "["; for (auto vvv : c) { s += to_string(vvv) + ","; }s += "]"; return s; }
void debug_impl() { cerr << endl; };
template <typename T1, typename... T2>void debug_impl(T1 a, T2... b) { cerr << " " << to_string(a); debug_impl(b...); }

#ifdef __ASD__
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_impl(__VA_ARGS__)
#else
#define dbg(...) ;
#endif
#define lng long long

vector<vector<int>> grav;
vector<int> d;
vector<bool> was;
vector<bool> leaf;

void dfs(int u, int p) {
	d[u]=(p==-1)?1:d[p]+1;
	was[u]=true;
	for(int v:grav[u]) {
		if (v!=p&&!was[v]) {
			dfs(v, u);
			leaf[u]=false;
		}
	}
}

int main() {
#ifdef __ASD__
	freopen("input.txt", "r", stdin);
	//freopen("nul", "w", stderr);
	//freopen("output.txt", "w", stdout);
	auto start_t = chrono::steady_clock::now();
#else
	ios_base::sync_with_stdio(false);
#endif

	int n, m, k;
	cin >> n >> m >> k;

	grav.resize(n);
	d.resize(n);
	was.resize(n);
	leaf.resize(n, true);

	for(int i=0;i<m;i++) {
		int u, v;
		cin >> u >> v;
		u--; v--;
		grav[u].push_back(v);
		grav[v].push_back(u);
	}

	dfs(0, -1);

	int l=0;

	for(int i=0;i<n;i++) {
		if (d[i]>=(n+k-1)/k) {
			vector<int> path;

			while (i!=0) {
				path.push_back(i);
				for(int j:grav[i]) {
					if (j==0||d[j]==d[i]-1) {
						i=j;break;
					}
				}
			}
			path.push_back(i);

			reverse(path.begin(), path.end());

			cout << "PATH" << endl;
			cout <<d[i] << endl;
			for(int x:path)cout<<x+1<<" ";
			cout<< endl;
			return 0;
		}
		if (leaf[i])l++;
	}

	for(int i=0;i<n;i++)dbg(i, grav[i]);

	cout << "CYCLES" << endl;
	cout << l << endl;

	for(int i=0;i<n;i++) {
		if (leaf[i]) {
			vector<int> cycle;

			for(int j : grav[i]) {
				if ((d[i] - d[j])%3!=2) {
					int x = i;
					while (x!=j) {
						cycle.push_back(x);
						for(int y:grav[x])if(d[y]==d[x]-1){x=y;break;}
					}
					cycle.push_back(x);
					break;
				}
			}
			if (cycle.empty()) {
				int u, v;
				for(int j : grav[i]) {
					if ((d[i] - d[j])%3==2) {
						if (u==-1) {
							u = j;
						} else if (v==-1) {
							v=j;
							break;
						}
					}
				}
				if (d[u] < d[v]) swap(u, v);
				while (u!=v) {
					cycle.push_back(u);
					for(int y:grav[u])if(d[y]==d[u]-1){u=y;break;}
				}
				cycle.push_back(u);
			}

			cout << cycle.size();
			for(int x:cycle)cout<<" " << x+1;
			cout << endl;
		}
	}

#ifdef __ASD__
	auto finish_t = chrono::steady_clock::now();
	cerr << "Elapsed " << chrono::duration_cast<chrono::milliseconds>(finish_t - start_t).count() << " ms" << endl;
#endif
	return 0;
}


#ifdef LOCAL
//#define _GLIBCXX_DEBUG
// #pragma comment(linker, "/STACK:102400000,102400000") // 在 Windows 上有效
#endif
#pragma GCC optimize("Ofast") // Ofast 等效于 -O3 -ffast-math
#include <bits/stdc++.h>

using namespace std;

#define FAST_READ ios::sync_with_stdio(false); cin.tie(nullptr);
#ifdef LOCAL
#define see(x) cout  <<"<DBG> " << #x << ": " << (x) << endl
#endif
#ifndef LOCAL
#define see(x)
#endif

template<typename T> void dprintln(const T &t) { cout << t << endl; } // for debug use
template<typename T, typename ...Args> void dprintln(const T &t, const Args &...rest) { cout << t << ' '; dprintln(rest...); }
template<typename T> void println(const T &t) { cout << t << '\n'; }
template<typename T, typename ...Args> void println(const T &t, const Args &...rest) { cout << t << ' '; println(rest...); }

template<typename T> void print(const T &t) { cout << t << ' '; }

template<typename T, typename ...Args> void print(const T &t, const Args &...rest) { cout << t << ' '; print(rest...); }

// this overload is chosen when there's only one argument
template<class T> void scan(T &t) { cin >> t; }
template<class T, class ...Args> void scan(T &a, Args &...rest) { cin >> a; scan(rest...); }
template <typename T> void read(vector<T> &vec) {for(auto &x: vec) cin >> x;}
using ull = unsigned long long;
using ll = long long;
using ul = unsigned long;
using vl = vector<ll>;
using vi = vector<int>;
using pii = pair<int,int>;
using vb = vector<bool>;
using vpii = vector<pii>;
template <typename int_t>
inline int_t lowbit(int_t x) {return x & -x;}
#define rng(i, a, b) for(int i = (a); i < (b); ++i)
#define down(i, b, a) for (int i = (b); i >= (a); i--)
#define rep(n) for(int _ = 0, __ = (int)n; _ < __; _++)
#define stp(i, a, b, c) for (int i = (a); i < (b); i += (c))
#define FOR(x, cont) for (const auto &x: cont)
#define For(x, cont) for (auto &x: cont)
#define all(x) begin(x), end(x)
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define SZ(x) (int)(x).size()
template <typename T, typename Comp = less<T>>
using pq = priority_queue<T, vector<T>, Comp>;
#define popcnt(x) __builtin_popcountll((x))
#define SET(arr, v) memset(arr, (v), sizeof (arr))
#define UNIQ(vec) (vec).erase(unique(all(vec)), end(vec))
#define LB(cont, x) int(lower_bound(all(cont), x) - begin(cont))
#define AI(name, n, m) vv<int> name(n, vi(m));
#define AL(name, n, m) vv<ll> name(size_t(n), vl(size_t(m)));
auto bet = [](const ll x, const ll y, const ll i) {
    return x <= i && i <= y;
};

template<typename T1, typename T2>
T1 ceil(T1 x, T2 y) { // y >= 1，是整数。需要注意 x + y - 1 是否会溢出
    return (x + y - 1) / y;
}

inline int h_bit(unsigned long long x) {
    return sizeof(unsigned long long) * 8 - 1 - __builtin_clzll(x);
}
int pow2(int x){ // power of 2
    return 1 << (h_bit((ull)x) + (x != lowbit(x)));
}

template <typename T>
struct bit {
    vector<T> a;
    function<T(T,T)> bin_op = [](const T &a, const T &b){return max(a, b);};
    explicit bit(int n, int v = 0) {
        a.resize((ul)n + 1);
        for (int i = 1; i <= n; ++i) a[i] = v;
    }

    T prefix(T x) {
        T res = 0;
        while (x) {
            res = bin_op(res, a[x]);
//            res += a[x];
            x -= x & -x;
        }
        return res;
    }

    T sum(int l, int r) {
        if (l > r) return 0;
        return sum(r) - sum(l - 1);
    }

    void modify(int x, T v) {
        while (x < a.size()) {
            a[x] = bin_op(a[x], v);
            x += x & -x;
        }
    }
    void clear(){
        fill(a.begin(), a.end(), 0);
    }
};

template <typename T>
struct r_bit {
    vector<T> a;
    function<T(T,T)> bin_op = [](const T &a, const T &b){return max(a, b);};

    explicit r_bit(int n, int v = 0) {
        a.resize((ul)n + 1);
        for (int i = 1; i <= n; ++i) a[i] = v;
    }

    T suffix(T x) {
        T res = 0;
        while (x < a.size()) {
            res = bin_op(res, a[x]);
//            res += a[x];
            x += x & -x;
        }
        return res;
    }

    T sum(int l, int r) {
        if (l > r) return 0;
        return sum(r) - sum(l - 1);
    }

    void modify(int x, T v) {
        while (x > 0) {
            a[x] = bin_op(a[x], v);
            x -= x & -x;
        }
    }
    void clear(){
        fill(a.begin(), a.end(), 0);
    }
};

vi get_prime(int n) {
    vi minp((ul)n + 1), p;
    for (int i = 2; i <= n; i++) {
        if (!minp[i]) {
            minp[i] = i;
            p.pb(i);
        }
        FOR(x, p) {
            if (x <= minp[i] && x * i <= n)
                minp[x * i] = x;
            else break;
        }
    }
    return p;
}

const int mod = 998244353; //记住 mod 的行号！

inline void mul(int &x, const int y) {
    x = int(ll(x) * y % mod);
}
inline int Mul(int x, const int y) {
    return (int)(ll(x) * y % mod);
}
inline void add(int &x, const int y) {
    x += y;
    if (x >= mod) x -= mod;
}
inline int Add(int x, int y) {
    x += y;
    if (x >= mod) x -= mod;
    return x;
}
inline int Sub(int x, int y) {
    x -= y; if (x < 0) x += mod;
    return x;
}
inline ll submod(ll x, ll y) {
    return x >= y ? x - y : x - y + mod;
}
inline ll addmod(ll x, ll y) {
    x += y;
    return x >= mod ? x - mod : x;
}

inline void sub_mod(ll &x, const ll y) {
    x -= y;
    if (x < 0) x += mod;
}
// alias templates
template<typename T> using vv = vector<vector<T>>;
template <typename T1, typename T2 = T1> using vp = vector<pair<T1,T2>>;
template<typename T, int n> using va = vector<array<T,n>>;

#ifdef __GNUC__
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
template <typename T>
using rank_tree = __gnu_pbds::tree<
        T,
        __gnu_pbds::null_type,
        less<T>,
        __gnu_pbds::rb_tree_tag,
        __gnu_pbds::tree_order_statistics_node_update>;
#endif

//union-find 并查集
struct UF{
    vi par, sz;
    int tot;
    explicit UF(int n) { //0-indexed
        par.assign(n, 0);
        sz.assign(n, 1);
        rng (i, 0, n) par[i] = i;
        tot = n;
    }

    int find(int x) {
        return x == par[x] ? x : par[x] = find(par[x]);
    }
    bool unite(int x, int y) {
        int rx = find(x), ry = find(y);
        if(rx != ry) {
            par[rx] = ry;
            --tot;
            return true;
        }
        return false;
    }
};

int fp (int x, ll n) { //fast power: hat off to quailty
    if(n < 0) {
        x = fp(x, mod - 2);
        n = -n;
    }
    int ans = 1;
    while(n){
        if(n&1) mul(ans, x);
        n /= 2;
        mul(x, x);
    }
    return ans;
}

vi get_popcnt(int n) {
    vi res((ul)n + 1);
    rng (i, 0, n) {
        if (i * 2 <= n) res[i * 2] = res[i];
        if ((i & 1) == 0) res[i + 1] = res[i] + 1;
    }
    return res;
}

using idx_t = long;
template <typename  T, typename Compare = std::less<T>>
struct ST{
    size_t n; // 0-indexed
    vv<T> a;
    template <typename ptr_t>
    ST(ptr_t beg, ptr_t end):n(end-beg){
        a.resize((size_t)h_bit(n)+1); // 注意：不能写成 h_bit(n)
        a[0].assign(beg, end);
        rng (i, 0, SZ(a)-1) {
            a[i+1].resize(n);
            rng(j, 0, n - (1 << i)) {
                a[i+1][j] = min(a[i][j], a[i][j+(1<<i)], Compare());
            }
            rng(j, n-(1 << i), n) {
                a[i+1][j] = a[i][j];
            }
        }
    }

    T query(idx_t l, idx_t r) { // l <=  r
        int i = h_bit(r - l + 1ul);
        return min(a[i][l], a[i][r+1-(1<<i)], Compare());
    }
};

using poly = vector<int>;

void bit_reverse_swap(vector<int> &a) {
    int n = SZ(a);
    for (int i = 1, j = n >> 1, k; i < n - 1; i++) {
        if (i < j) swap(a[i], a[j]);
        //tricky
        for (k = n >> 1; j >= k; j -= k, k >>= 1);    //inspect the highest "1"
        j += k;
    }
}

void FFT(vector<int> &a, int type) {
    bit_reverse_swap(a);
    int n = SZ(a);
    for (int i = 2; i <= n; i *= 2) {
        const auto wi = fp(3, type * (mod - 1) / i); // i次单位根
        for (int j = 0; j < n; j += i) {
            auto w(1);
            for (int k = j, h = i >> 1; k < j + h; k++) {
                auto t = Mul(w, a[k + h]), u = a[k];
                a[k] = Add(u, t);
                a[k + h] = Sub(u, t);
                mul(w, wi);
            }
        }
    }
    const int inv = fp(n, -1);
    if (type == -1) for (auto &x : a) mul(x, inv);
}

void fp(poly &a, const int n) {
    a.resize((ul)pow2((SZ(a)-1) * n + 1));
    FFT(a, 1);
    for(auto &x: a) x = fp(x, n);
    FFT(a, -1);
}
// DEBUG code by tourist
string to_string(string s) {
    return '"' + s + '"';
}

string to_string(const char* s) {
    return to_string((string) s);
}

string to_string(bool b) {
    return (b ? "true" : "false");
}

template <typename A, typename B>
string to_string(pair<A, B> p) {
    return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}

template <typename A>
string to_string(A v) {
    bool first = true;
    string res = "{";
    for (const auto &x : v) {
        if (!first) {
            res += ", ";
        }
        first = false;
        res += to_string(x);
    }
    res += "}";
    return res;
}

void debug_out() { cerr << endl; }

template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
    cerr << " " << to_string(H);
    debug_out(T...);
}

#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// end DEBUG

// ZJU Monthly Jan.19
///////////////////////////////////////////////////////
const int N = (int)2e3+5, M = 1005;

vv<int> g;
vi dep, fa;

vb is_leaf;
vv<int> back;

void dfs(int u, int f) {
    fa[u] = f;
    dep[u] = dep[f] + 1;
    FOR(v, g[u]) {
        if (dep[v] == 0) {
            dfs(v, u);
            is_leaf[u] = false;
        }
        else if (dep[v] < dep[u] && v != f) {
            back[u].pb(v);
        }
    }
}

int main() {
    FAST_READ
#ifdef LOCAL
    ifstream in("main.in");
    cin.rdbuf(in.rdbuf());
#endif

    int n, m, k; scan(n, m, k);

    g.resize(n+1);
    dep.resize(n + 1), fa.resize(n + 1);
    is_leaf.resize(n + 1, true);
    back.resize(n + 1);

    int tar = (n + k - 1) / k;
    rep(m) {
        int u, v; scan(u, v);
        g[u].pb(v), g[v].pb(u);
    }

    dfs(1, 0);

    rng (i, 1, n + 1) if(dep[i] >= tar) {
            println("PATH");
            println(dep[i]);
            for (; i; print(i), i = fa[i]);
            cout << endl;
            return 0;
        }

    // l * (d - 1) + 1 >= n
    // d < ceil(n / k) iff. d * k < n iff. d * k <= n - 1
    // l >= (n - 1) / (d - 1) >= d * k / (d - 1) > k

    println("CYCLES");
    for (int i = 1, c = 0; i <= n && c < k; ++i) if (is_leaf[i]) {
            ++c;
            bool flag = false;
            rng (j, 0, 2) {
                int x = back[i][j];
                int len = dep[i] - dep[x] + 1;
                if (len % 3) {
                    flag = true;
                    println(len);
                    for (int y = i; ; y=fa[y]) {
                        print(y);
                        if (y == x) break;
                    }
                    cout << endl;
                    break;
                }
            }
            if (!flag) {
                int u = back[i][0], v = back[i][1];
                if (dep[u] < dep[v]) swap(u, v);
                println(dep[u] - dep[v] + 2);
                print(i);
                int x = u;
                while (true) {
                    print(x);
                    if (x == v) break;
                    x = fa[x];
                }
                cout << endl;
            }
        }

#ifdef LOCAL
//    cout << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
    return 0;
}


#ifdef LOCAL
//#define _GLIBCXX_DEBUG
// #pragma comment(linker, "/STACK:102400000,102400000") // 在 Windows 上有效
#endif
#pragma GCC optimize("Ofast") // Ofast 等效于 -O3 -ffast-math
#include <bits/stdc++.h>

using namespace std;

#define FAST_READ ios::sync_with_stdio(false); cin.tie(nullptr);
#ifdef LOCAL
#define see(x) cout  <<"<DBG> " << #x << ": " << (x) << endl
#endif
#ifndef LOCAL
#define see(x)
#endif

template<typename T> void dprintln(const T &t) { cout << t << endl; } // for debug use
template<typename T, typename ...Args> void dprintln(const T &t, const Args &...rest) { cout << t << ' '; dprintln(rest...); }
template<typename T> void println(const T &t) { cout << t << '\n'; }
template<typename T, typename ...Args> void println(const T &t, const Args &...rest) { cout << t << ' '; println(rest...); }

template<typename T> void print(const T &t) { cout << t << ' '; }

template<typename T, typename ...Args> void print(const T &t, const Args &...rest) { cout << t << ' '; print(rest...); }

// this overload is chosen when there's only one argument
template<class T> void scan(T &t) { cin >> t; }
template<class T, class ...Args> void scan(T &a, Args &...rest) { cin >> a; scan(rest...); }
template <typename T> void read(vector<T> &vec) {for(auto &x: vec) cin >> x;}
using ull = unsigned long long;
using ll = long long;
using ul = unsigned long;
using vl = vector<ll>;
using vi = vector<int>;
using pii = pair<int,int>;
using vb = vector<bool>;
using vpii = vector<pii>;
template <typename int_t>
inline int_t lowbit(int_t x) {return x & -x;}
#define rng(i, a, b) for(int i = (a); i < (b); ++i)
#define down(i, b, a) for (int i = (b); i >= (a); i--)
#define rep(n) for(int _ = 0, __ = (int)n; _ < __; _++)
#define stp(i, a, b, c) for (int i = (a); i < (b); i += (c))
#define FOR(x, cont) for (const auto &x: cont)
#define For(x, cont) for (auto &x: cont)
#define all(x) begin(x), end(x)
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define SZ(x) (int)(x).size()
template <typename T, typename Comp = less<T>>
using pq = priority_queue<T, vector<T>, Comp>;
#define popcnt(x) __builtin_popcountll((x))
#define SET(arr, v) memset(arr, (v), sizeof (arr))
#define UNIQ(vec) (vec).erase(unique(all(vec)), end(vec))
#define LB(cont, x) int(lower_bound(all(cont), x) - begin(cont))
#define AI(name, n, m) vv<int> name(n, vi(m));
#define AL(name, n, m) vv<ll> name(size_t(n), vl(size_t(m)));
auto bet = [](const ll x, const ll y, const ll i) {
    return x <= i && i <= y;
};

template<typename T1, typename T2>
T1 ceil(T1 x, T2 y) { // y >= 1，是整数。需要注意 x + y - 1 是否会溢出
    return (x + y - 1) / y;
}

inline int h_bit(unsigned long long x) {
    return sizeof(unsigned long long) * 8 - 1 - __builtin_clzll(x);
}
int pow2(int x){ // power of 2
    return 1 << (h_bit((ull)x) + (x != lowbit(x)));
}

template <typename T>
struct bit {
    vector<T> a;
    function<T(T,T)> bin_op = [](const T &a, const T &b){return max(a, b);};
    explicit bit(int n, int v = 0) {
        a.resize((ul)n + 1);
        for (int i = 1; i <= n; ++i) a[i] = v;
    }

    T prefix(T x) {
        T res = 0;
        while (x) {
            res = bin_op(res, a[x]);
//            res += a[x];
            x -= x & -x;
        }
        return res;
    }

    T sum(int l, int r) {
        if (l > r) return 0;
        return sum(r) - sum(l - 1);
    }

    void modify(int x, T v) {
        while (x < a.size()) {
            a[x] = bin_op(a[x], v);
            x += x & -x;
        }
    }
    void clear(){
        fill(a.begin(), a.end(), 0);
    }
};

template <typename T>
struct r_bit {
    vector<T> a;
    function<T(T,T)> bin_op = [](const T &a, const T &b){return max(a, b);};

    explicit r_bit(int n, int v = 0) {
        a.resize((ul)n + 1);
        for (int i = 1; i <= n; ++i) a[i] = v;
    }

    T suffix(T x) {
        T res = 0;
        while (x < a.size()) {
            res = bin_op(res, a[x]);
//            res += a[x];
            x += x & -x;
        }
        return res;
    }

    T sum(int l, int r) {
        if (l > r) return 0;
        return sum(r) - sum(l - 1);
    }

    void modify(int x, T v) {
        while (x > 0) {
            a[x] = bin_op(a[x], v);
            x -= x & -x;
        }
    }
    void clear(){
        fill(a.begin(), a.end(), 0);
    }
};

vi get_prime(int n) {
    vi minp((ul)n + 1), p;
    for (int i = 2; i <= n; i++) {
        if (!minp[i]) {
            minp[i] = i;
            p.pb(i);
        }
        FOR(x, p) {
            if (x <= minp[i] && x * i <= n)
                minp[x * i] = x;
            else break;
        }
    }
    return p;
}

const int mod = 998244353; //记住 mod 的行号！

inline void mul(int &x, const int y) {
    x = int(ll(x) * y % mod);
}
inline int Mul(int x, const int y) {
    return (int)(ll(x) * y % mod);
}
inline void add(int &x, const int y) {
    x += y;
    if (x >= mod) x -= mod;
}
inline int Add(int x, int y) {
    x += y;
    if (x >= mod) x -= mod;
    return x;
}
inline int Sub(int x, int y) {
    x -= y; if (x < 0) x += mod;
    return x;
}
inline ll submod(ll x, ll y) {
    return x >= y ? x - y : x - y + mod;
}
inline ll addmod(ll x, ll y) {
    x += y;
    return x >= mod ? x - mod : x;
}

inline void sub_mod(ll &x, const ll y) {
    x -= y;
    if (x < 0) x += mod;
}
// alias templates
template<typename T> using vv = vector<vector<T>>;
template <typename T1, typename T2 = T1> using vp = vector<pair<T1,T2>>;
template<typename T, int n> using va = vector<array<T,n>>;

#ifdef __GNUC__
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
template <typename T>
using rank_tree = __gnu_pbds::tree<
        T,
        __gnu_pbds::null_type,
        less<T>,
        __gnu_pbds::rb_tree_tag,
        __gnu_pbds::tree_order_statistics_node_update>;
#endif

//union-find 并查集
struct UF{
    vi par, sz;
    int tot;
    explicit UF(int n) { //0-indexed
        par.assign(n, 0);
        sz.assign(n, 1);
        rng (i, 0, n) par[i] = i;
        tot = n;
    }

    int find(int x) {
        return x == par[x] ? x : par[x] = find(par[x]);
    }
    bool unite(int x, int y) {
        int rx = find(x), ry = find(y);
        if(rx != ry) {
            par[rx] = ry;
            --tot;
            return true;
        }
        return false;
    }
};

int fp (int x, ll n) { //fast power: hat off to quailty
    if(n < 0) {
        x = fp(x, mod - 2);
        n = -n;
    }
    int ans = 1;
    while(n){
        if(n&1) mul(ans, x);
        n /= 2;
        mul(x, x);
    }
    return ans;
}

vi get_popcnt(int n) {
    vi res((ul)n + 1);
    rng (i, 0, n) {
        if (i * 2 <= n) res[i * 2] = res[i];
        if ((i & 1) == 0) res[i + 1] = res[i] + 1;
    }
    return res;
}

using idx_t = long;
template <typename  T, typename Compare = std::less<T>>
struct ST{
    size_t n; // 0-indexed
    vv<T> a;
    template <typename ptr_t>
    ST(ptr_t beg, ptr_t end):n(end-beg){
        a.resize((size_t)h_bit(n)+1); // 注意：不能写成 h_bit(n)
        a[0].assign(beg, end);
        rng (i, 0, SZ(a)-1) {
            a[i+1].resize(n);
            rng(j, 0, n - (1 << i)) {
                a[i+1][j] = min(a[i][j], a[i][j+(1<<i)], Compare());
            }
            rng(j, n-(1 << i), n) {
                a[i+1][j] = a[i][j];
            }
        }
    }

    T query(idx_t l, idx_t r) { // l <=  r
        int i = h_bit(r - l + 1ul);
        return min(a[i][l], a[i][r+1-(1<<i)], Compare());
    }
};

using poly = vector<int>;

void bit_reverse_swap(vector<int> &a) {
    int n = SZ(a);
    for (int i = 1, j = n >> 1, k; i < n - 1; i++) {
        if (i < j) swap(a[i], a[j]);
        //tricky
        for (k = n >> 1; j >= k; j -= k, k >>= 1);    //inspect the highest "1"
        j += k;
    }
}

void FFT(vector<int> &a, int type) {
    bit_reverse_swap(a);
    int n = SZ(a);
    for (int i = 2; i <= n; i *= 2) {
        const auto wi = fp(3, type * (mod - 1) / i); // i次单位根
        for (int j = 0; j < n; j += i) {
            auto w(1);
            for (int k = j, h = i >> 1; k < j + h; k++) {
                auto t = Mul(w, a[k + h]), u = a[k];
                a[k] = Add(u, t);
                a[k + h] = Sub(u, t);
                mul(w, wi);
            }
        }
    }
    const int inv = fp(n, -1);
    if (type == -1) for (auto &x : a) mul(x, inv);
}

void fp(poly &a, const int n) {
    a.resize((ul)pow2((SZ(a)-1) * n + 1));
    FFT(a, 1);
    for(auto &x: a) x = fp(x, n);
    FFT(a, -1);
}
// DEBUG code by tourist
string to_string(string s) {
    return '"' + s + '"';
}

string to_string(const char* s) {
    return to_string((string) s);
}

string to_string(bool b) {
    return (b ? "true" : "false");
}

template <typename A, typename B>
string to_string(pair<A, B> p) {
    return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}

template <typename A>
string to_string(A v) {
    bool first = true;
    string res = "{";
    for (const auto &x : v) {
        if (!first) {
            res += ", ";
        }
        first = false;
        res += to_string(x);
    }
    res += "}";
    return res;
}

void debug_out() { cerr << endl; }

template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
    cerr << " " << to_string(H);
    debug_out(T...);
}

#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// end DEBUG

// ZJU Monthly Jan.19
///////////////////////////////////////////////////////
const int N = (int)2e3+5, M = 1005;

vv<int> g;
vi dep, fa;

vb is_leaf;
vv<int> back;

void dfs(int u, int f) {
    fa[u] = f;
    dep[u] = dep[f] + 1;
    FOR(v, g[u]) {
        if (dep[v] == 0) {
            dfs(v, u);
            is_leaf[u] = false;
        }
        else if (dep[v] < dep[u] && v != f) {
            back[u].pb(v);
        }
    }
}

int main() {
    FAST_READ
#ifdef LOCAL
    ifstream in("main.in");
    cin.rdbuf(in.rdbuf());
#endif

    int n, m, k; scan(n, m, k);

    g.resize(n+1);
    dep.resize(n + 1), fa.resize(n + 1);
    is_leaf.resize(n + 1, true);
    back.resize(n + 1);

    int tar = (n + k - 1) / k;
    rep(m) {
        int u, v; scan(u, v);
        g[u].pb(v), g[v].pb(u);
    }

    dfs(1, 0);

    rng (i, 1, n + 1) if(dep[i] >= tar) {
        println("PATH");
        println(dep[i]);
        int j = i;
        while (j) {
            print(j);
            j = fa[j];
        }
        cout << endl;
        return 0;
    }

    // l * (d - 1) + 1 >= n
    // d < ceil(n / k) iff. d * k < n iff. d * k <= n - 1
    // l >= (n - 1) / (d - 1) >= d * k / (d - 1) > k
    println("CYCLES");
    for (int i = 1, c = 0; i <= n && c < k; ++i) if (is_leaf[i]) {
            ++c;
            bool flag = false;
            FOR(j, back[i]) {
                int len = dep[i] - dep[j] + 1;
                if (len % 3) {
                    flag = true;
                    println(len);
                    int x = i;
                    while (true) {
                        print(x);
                        if (x == j) break;
                        x = fa[x];
                    }
                    cout << endl;
                    break;
                }
            }
            if (!flag) {
                int u = back[i][0], v = back[i][1];
                if (dep[u] < dep[v]) swap(u, v);
                println(dep[u] - dep[v] + 2);
                print(i);
                int x = u;
                while (true) {
                    print(x);
                    if (x == v) break;
                    x = fa[x];
                }
                cout << endl;
            }
        }

#ifdef LOCAL
//    cout << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
    return 0;
}