#include <algorithm>
#include <array>
#include <cassert>
#include <iostream>
#include <map>
#include <set>
#include <vector>

using namespace std;

struct Permutation {
  Permutation(vector<int> perm) : perm_(std::move(perm)) {
    sorted_ = std::is_sorted(perm_.begin(), perm_.end());
    ComputeCycles();
  }

  void ComputeCycles() {
    cycle_sizes_.clear();
    cycle_sizes_.resize(perm_.size() + 1, 0);
    set<int> remaining(perm_.begin(), perm_.end());
    while (!remaining.empty()) {
      int begin = *remaining.begin();
      int x = begin;
      int cycle_size = 0;
      do {
        remaining.erase(x);
        x = perm_[x];
        cycle_size++;
      } while (x != begin);
      cycle_sizes_[cycle_size]++;
    }
  }

  bool operator<(const Permutation &other) const {
    return cycle_sizes_ < other.cycle_sizes_;
  }

  Permutation Swap(int i, int j) const {
    vector<int> new_perm(perm_);
    swap(new_perm[i], new_perm[j]);
    return Permutation(new_perm);
  }

  vector<int> perm_;
  vector<int> cycle_sizes_;
  bool sorted_ = false;
};

using State = pair<Permutation, int>;
using States = map<pair<Permutation, int>, int64_t>;
const int64_t MOD = 1'000'000'007;

int64_t solve(States &states, State state) {
  auto it = states.find(state);
  if (it != states.end())
    return it->second;
  const auto &[perm, k] = state;
  if (k == 0) {
    return perm.sorted_;
  }
  int64_t count = 0;
  const int n = perm.perm_.size();
  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      Permutation new_perm = perm.Swap(i, j);
      count += solve(states, {new_perm, k - 1});
    }
  }
  count %= MOD;
  return states[state] = count;
}

int main() {
  int N, K, T;
  cin >> N >> K >> T;
  States states;
  for (int t = 0; t < T; ++t) {
    vector<int> perm;
    for (int i = 0; i < N; ++i) {
      int x;
      cin >> x;
      perm.push_back(x - 1);
    }
    cout << solve(states, {Permutation(perm), K}) << endl;
  }
}