OI I - wys

// https://szkopul.edu.pl/problemset/problem/KrDYc6Wu8OK_pwfh9EKVkrr7/site/?key=statement

#include <bits/stdc++.h>

// #define GARY_DBG
#define GARY_LIB

constexpr int sizik = 1000 * 1001;

#define ar std::array

typedef std::vector<std::vector<int>> _kra;

struct Point {
    int x, y;
    Point(int x1 = 0, int y1 = 0) : x(x1), y(y1) {}
    bool operator==(const Point& other) { return x == other.x && y == other.y; }
    bool operator!=(const Point& other) { return !(*this == other); }
};

int dx[] = {0, 1, 1, 0, -1, -1};
int dy[] = {1, 1, 0, -1, -1, 0};

Point move(const Point& p, int dir) {
    return {p.x + dx[dir], p.y + dy[dir]};
}

typedef std::vector<Point> Figura;

int k_dir(const Point& a, const Point& b) {
    for (int i = 0; i < 6; i++) {
        if (move(a, i) == b) {
            return i;
        }
    }
    return -1;
}

int mv[] = {4, 5, 0, 1, 2};
char get_mv(char c) {
    return mv[c - 'a'];
}

Figura decode(const std::string& s) {
    Figura ret;
    Point start;
    ret.push_back(start);

    int k = 1;
    for (const auto& c : s) {
        k = (k + get_mv(c)) % 6;
        start = move(start, k);
        ret.push_back(start);
    }

    return ret;
}

std::string smallest_rot(std::string s) {
    std::vector<std::string> v{s};
    int n = (int)s.size();
    for (int i = 0; i < n; i++) {
        std::rotate(s.begin(), s.begin() + 1, s.end());
        v.push_back(s);
    }
    return *std::min_element(v.begin(), v.end());
}

std::string zakoduj(const Figura& v) {
    int n = (int)v.size() - 1;
    if (n < 1) return "";

    std::vector<int> dirs;
    for (int i = 0; i < n; i++) {
        dirs.push_back(k_dir(v[i], v[i + 1]));
    }

    std::string s = "";
    for (int i = 0; i < n; i++) {
        int d1 = dirs[i];
        int d2 = dirs[(i + 1) % n];

        int diff = (d2 - d1 + 8) % 6;
        s += (char)('a' + diff);
    }

    std::string s1 = smallest_rot(s);

    std::string s_rev = s;
    std::reverse(s_rev.begin(), s_rev.end());
    std::string s2 = smallest_rot(s_rev);

    return std::min(s1, s2);
}

int m(int x, int y) {
    if (x >= y) x -= y;
    return x;
}

std::vector<std::string> rozmnoz(std::string s_kod) {
    Figura v = decode(s_kod);
    std::vector<Figura> ret;
    v.pop_back();
    int n = (int)v.size();
    for (int i = 0; i < n; i++) {
        Point A = v[i], B = v[m(i + 1, n)], next = v[m(i + 2, n)], prev = v[m(i - 1 + n, n)];
        int k = k_dir(A, B);
        int k_C = (k + 4) % 6;
        Point C = move(B, k_C);

        if (C == prev && C != next) continue;

        if (C == next && C == prev) {
            int x = ret.size();
            ret.push_back({});
            for (int j = 0; j < n; j++) {
                if (j == i || j == m(i + 1, n) || j == m(i + 2, n)) {
                    //
                } else {
                    ret[x].push_back(v[j]);
                }
            }
        } else if (C == next) {
            int x = ret.size();
            ret.push_back({});
            for (int j = 0; j < n; j++) {
                if (j == m(i + 1, n)) {
                    ret[x].push_back(C);
                    j++;
                } else {
                    ret[x].push_back(v[j]);
                }
            }
        } else {
            int x = ret.size();
            ret.push_back({});
            for (int j = 0; j < n; j++) {
                ret[x].push_back(v[j]);
                if (j == i) {
                    ret[x].push_back(C);
                }
            }
        }
    }

    std::set<std::string> dzieci_s;
    std::vector<std::string> dzieci_v;

    for (auto F : ret) {
        F.push_back(F.front());
        auto s1 = zakoduj(F);
        if (find(s1.begin(), s1.end(), 'f') != s1.end()) {
        } else {
            dzieci_s.insert(s1);
        }
    }
    for (const auto& a : dzieci_s) {
        dzieci_v.push_back(a);
    }

    return dzieci_v;
}

void solve() {
    std::vector<std::vector<std::string>> zbior(11);
    zbior[1] = {"eee"};
    for (int i = 2; i <= 10; i++) {
        std::set<std::string> dzieci_s;
        std::vector<std::string> dzieci_v;
        for (const auto& a : zbior[i - 1]) {
            auto ret = rozmnoz(a);
            for (const auto& b : ret) {
                dzieci_s.insert(b);
            }
        }
        for (const auto& a : dzieci_s) {
            dzieci_v.push_back(a);
        }
        std::sort(dzieci_v.begin(), dzieci_v.end());
        zbior[i] = dzieci_v;
    }

    int t;
    std::cin >> t;

    for (; t > 0; t--) {
        char c;
        std::cin >> c;

        if (c == 'N') {
            int x;
            std::cin >> x;

            std::cout << zbior[x].size() << '\n';
            for (const auto& a : zbior[x]) {
                std::cout << a << " ";
            }
            std::cout << '\n';
        } else if (c == 'K') {
            std::string r;
            std::cin >> r;

            auto ret = rozmnoz(r);
            std::sort(ret.begin(), ret.end());
            std::cout << ret.size() << '\n';
            for (const auto& a : ret) {
                std::cout << a << ' ';
            }
            std::cout << '\n';
        }
    }
}

int32_t main() {
#ifndef GARY_DBG
    std::ios_base::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);
#endif

    int t = 1;
    // std::cin >> t;

    for (; t > 0; t--) {
        solve();
    }

    return 0;
}