#include <iostream>
#include <vector>
#include <assert.h>
#include <unordered_map>
#include <string>
#include <algorithm>

using namespace std;

typedef vector<int> transitions;
typedef vector<int> word;

struct Automaton {
    int states;
    vector<int> accept;
    vector<transitions> delta;
    int initial;

    Automaton(int in, int n, const vector<transitions> &d, const vector<int> &acc) {
        assert(in < n);
        assert(d.size() == n);
        
        accept = acc;
        delta.resize(n);
        for (int i = 0; i < d.size(); i++) {
            delta[i] = transitions(d[i]);
        }
        in = initial;
        states = n;
    }

    int apply(const word &w, int beg) {
        int crawl = beg;
        for (auto c: w) {
            crawl = delta[crawl][c];
        }
        return crawl;
    }

    bool check(const word &s) {
        int q = apply(s, initial);
        for (auto i: accept) {
            if (q == i)
                return true;
        }
        return false;
    }

    void dump() {
        cout << "States: " << states << "; accepting: ";
        for (auto i: accept) cout << i << " ";
        cout << "\n";
        cout << "Transition table:\n";
        for (int i = 0; i < states; i++) {
            cout << i << ":";
            for (int j = 0; j < delta[i].size(); j++) {
                cout << "\t--" << (char)(j + 'a') << "--> " << delta[i][j] << "\n";
            }
        }
    }
};

void fill_accepts(int mask, int states, vector<int> &acc) {
    acc.clear();
    for (int i = 0; i < states; i++) {
        if (mask & (1<<i))
            acc.push_back(1);
        else  
            acc.push_back(0);
    }
}

bool nextperm(int states, transitions &t, int alph_sz) {
    for (int s = 0; s < alph_sz; s++) {
        t[s]++;
        if (t[s] == states) {
            t[s] = 0;
        }
        else {
            return true;
        }
    }
    return false;
}

void reset_transition(transitions &t, int alph_sz) {
    for (int s = 0; s < alph_sz; s++) {
        t[s] = 0;
    }
}

bool next_word(word &w, int alph_sz) {
    for (int i = 0; i < w.size(); i++) {
        w[i]++;
        if (w[i] == alph_sz) {
            w[i] = 0;
        } else return true;
    }
    return false;
}

vector<word> generate_words(int max_len, int alph_sz) {
    vector<word> result;
    for (int len = 0; len <= max_len; len++) {
        word w;
        for (int i = 0; i < len; i++) w.push_back(0);
        do {
            result.push_back(w);
        } while (next_word(w, alph_sz));
    }
    return result;
}

void get_transitions(Automaton &aut, word &w, vector<int> &res) {
    res.clear();
    for (int i = 0; i < aut.states; i++) {
        res.push_back(aut.apply(w, i));
    }
}

int my_power(int a, int b) {
    if (b == 0) return 1;
    return a * my_power(a, b-1);
}

bool check_automaton(vector<word> &words, Automaton &aut) {
    vector<vector<int>> funcs;
    for (auto w: words) {
        vector<int> trans;
        get_transitions(aut, w, trans);
        funcs.push_back(trans);            
    }
    sort(funcs.begin(), funcs.end());
    auto it = unique(funcs.begin(), funcs.end());
    funcs.erase(it, funcs.end());

    cout << funcs.size() << "\n";
    if (funcs.size() == my_power(aut.states, aut.states)) {
        cout << "mamy to!!\n";
        aut.dump();
        return true;
    }
    return false;
}

vector<Automaton> generate_automatons(int states, int alph_sz, vector<word> &words) {   
    vector<Automaton> result;
    vector<transitions> delta;
    vector<int> accepts;

    for (int i = 0; i < states; i++) {
        delta.push_back(transitions());
        for (int s = 0; s < alph_sz; s++) {
            delta[i].push_back(0);
        }
    }

    /* loop over accepting states */
    // for (int i = 0; i < (1<<states); i++) {
    //     if (i == 0) continue;
    fill_accepts(1, states, accepts);
    
    /* loop over possible transitions */
    bool last = false;
    while (!last) {
        Automaton a(0, states, delta, accepts);
        if (check_automaton(words, a)) {
            return result;
        }
        // result.push_back(a);
        last = true;
        for (int i = 0; i < states; i++) {
            if (nextperm(states, delta[i], alph_sz)) {
                last = false;
                break;
            }
            else {
                reset_transition(delta[i], alph_sz);
            }
        }   
    }
    // }

    return result;
}

Automaton automaton_from_input() {
    int states, alph_sz;
    cin >> states >> alph_sz;
    
    vector<int> accept;
    vector<transitions> delta;
    int initial;

    fill_accepts(1, states, accept);

    initial = 0;
    for (int i = 0; i < states; i++) {
        cout << i << ":";
        delta.push_back(transitions());
        for (int j = 0; j < alph_sz; j++) {
            int x;
            cout << "\t--" << (char)(j + 'a') << "--> ? ";
            cin >> x;
            delta[i].push_back(x);
        }
    }

    return Automaton(0, states, delta, accept);
}

int main(int argc, char *argv[]) {
    if (argc != 4) {
        fprintf(stderr, "Usage: %s states alph_sz word_sz\n", argv[0]);
        return -1;
    }

    int states = atoi(argv[1]);
    int alph_sz = atoi(argv[2]);
    int word_sz = atoi(argv[3]);


    // vector<Automaton> automatons = generate_automatons(states, alph_sz);

    // for (auto a: automatons) {
    //     a.dump();
    //     cout << "\n";
    // }

    fprintf(stderr, "Generating words...\n");
    vector<word> words = generate_words(word_sz, alph_sz);

    // for (auto w: words) {
    //     for (auto c: w) {
    //         cout << (char)(c + 'a');
    //     }
    //     cout << "\n";
    // }
    // fprintf(stderr, "Generating %d automatons...\n", my_power(alph_sz, alph_sz * states));
    // generate_automatons(states, alph_sz, words);

    Automaton aut = automaton_from_input();
    check_automaton(words, aut);
}