### Поиск треугольников в графе

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define long ll
#define double ld
#define all(x) begin(x), end(x)

const int N = 3e5;
vector<int> g[N];
vector<int> r[N];
int deg[N];
int n, m, k;

inline bool deg_cmp(int a, int b) {
    if (deg[a] != deg[b]) {
        return deg[a] < deg[b];
    }
    return a < b;
}

int cyc_used[N];

vector<vector<int>> cycles;

void check_triangle(int a, int b, int c) {
    //cerr << a << ' ' << b << ' ' << c << endl;
    if (cyc_used[a] || cyc_used[b] || cyc_used[c]) {
        return;
    }
    vector<int> temp;
    for (int i = 0, d = min((int)g[a].size(), 3); i < d; ++i) {
        if (g[a][i] != b && g[a][i] != c) {
            temp.push_back(g[a][i]);
        }
    }
    for (int i = 0, d = min((int)g[b].size(), 3); i < d; ++i) {
        if (g[b][i] != a && g[a][i] != c) {
            temp.push_back(g[b][i]);
        }
    }
    for (int i = 0, d = min((int)g[c].size(), 3); i < d; ++i) {
        if (g[c][i] != a && g[c][i] != b) {
            temp.push_back(g[c][i]);
        }
    }
    sort(temp.begin(), temp.end(), deg_cmp);
    for (int i : temp) {
        if (!cyc_used[i]) {
            vector<int> tt = { i, a, b, c };
            for (int p = 0; p < 4; ++p) {
                if (!cyc_used[tt[p]]) {
                    swap(tt[0], tt[p]);
                }
            }
            if (!cyc_used[tt[0]]) {
                cycles.push_back(tt);
                cyc_used[tt[0]]=  true;
                cyc_used[tt[1]]=  true;
                cyc_used[tt[2]]=  true;
                cyc_used[tt[3]]=  true;
            }

        }
    }
}

void read_input() {
#ifdef LC
    assert(freopen("input.txt", "r", stdin));
#endif
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> n >> m >> k;
    for (int a, b, i = 0; i < m; ++i) {
        cin >> a >> b;
        --a;
        --b;
        g[a].push_back(b);
        g[b].push_back(a);
        ++deg[a];
        ++deg[b];
    }
}

void find_triangles() {
    for (int i = 0; i < n; ++i) {
        for (int j : g[i]) {
            if (deg_cmp(i, j)) {
                r[i].push_back(j);
            }
        }
        sort(r[i].begin(), r[i].end(), deg_cmp);
    }
    for (int i = 0; i < n; ++i) {
        for (int j : r[i]) {
            auto a = r[i].begin();
            auto b = r[j].begin();
            while (a != r[i].end() && b != r[j].end()) {
                if (*a == *b) {
                    check_triangle(i, j, *a);
                    ++a;
                    ++b;
                } else if (deg_cmp(*a, *b)) {
                    ++a;
                } else {
                    ++b;
                }
            }
        }
    }
}

int used[N], cur_used = 0;
int dist[N];
int pr[N];
int path[N], path_p;


void dfs(int v, int len) {
    ++cur_used;
    pr[v] = N - 1;
    dist[v] = 1;
    used[v] = cur_used;
    path_p = 0;
    path[path_p++] = v;
    while (path_p > 0) {
        v = path[--path_p];
        assert(used[v] == cur_used);
        if (dist[v] >= len) {
            cout << "PATH\n";
            vector<int> pt;
            int x = v;
            while (used[x] >= cur_used) {
                pt.push_back(x);
                x = pr[x];
            }
            reverse(all(pt));
            cout << pt.size() << '\n';
            for (auto e : pt) {
                cout << e + 1 << ' ';
            }
            cout << '\n';
            exit(0);
        }
        for (int u : g[v]) {
            if (used[u] < cur_used) {
                path[path_p++] = u;
                dist[u] = dist[v] + 1;
                used[u] = cur_used;
                pr[u] = v;
            }
        }
    }
}

int main() {
    read_input();
    find_triangles();
    if ((int)cycles.size() >= k) {
        cout << "CYCLES\n";
        for (int i = 0; i < k; ++i) {
            cout << cycles[i].size() << '\n';
            for (int e : cycles[i]) {
                cout << e + 1 << ' ';
            }
            cout << '\n';
        }
        return 0;
    }
    mt19937 randint;
    while (clock() < 0.95 * CLOCKS_PER_SEC) {
        int i = (int)(randint() % (size_t)n);
        dfs(i, (n + k - 1) / k);
    }
    cout << "-1\n";
    return 0;
}