#include <bits/stdc++.h>
#define int long long
using namespace std;

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

namespace std {
template <typename T1, typename T2> string to_string(pair<T1, T2> v) {
  string res = "{" + to_string(v.first) + ", " + to_string(v.second) + "}";
  return res;
}
} // namespace std

void dbg_out() { cout << endl; }
template <typename Head, typename... Tail> void dbg_out(Head H, Tail... T) {
  cout << ' ' << to_string(H);
  dbg_out(T...);
}

#ifdef DEBUG
#define dbg(...) cout << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)
#else
#define dbg(...)
#endif

const pair<int, int> deltas[] = {{0, 1}, {1, 0}, {1, 1}, {1, -1}};

void solve() {
  int dim, nbNec;
  cin >> dim >> nbNec;

  array<vector<pair<int, int>>, 2> moves;
  for (int i = 0; i < dim; ++i)
    for (int j = 0; j < dim; ++j) {
      char c;
      cin >> c;
      if (c == 'o')
        moves[0].emplace_back(i, j);
      else if (c == 'x')
        moves[1].emplace_back(i, j);
    }
  vector<string> grid(dim, string(dim, '.'));

  auto isSafe = [&](int lig, int col) {
    return lig >= 0 and col >= 0 and col < dim and lig < dim;
  };

  auto checkWin = [&](int lig, int col) {
    for (auto [dx, dy] : deltas) {
      int l = 0, r = 0;
      while (isSafe(lig + (l - 1) * dy, col + (l - 1) * dx) and
             grid[lig + (l - 1) * dy][col + (l - 1) * dx] == grid[lig][col])
        --l;
      while (isSafe(lig + (r + 1) * dy, col + (r + 1) * dx) and
             grid[lig + (r + 1) * dy][col + (r + 1) * dx] == grid[lig][col])
        ++r;
      if (r - l + 1 >= nbNec)
        return true;
    }
    return false;
  };

  int movesL = moves[0].size();
  int movesR = moves[1].size();

  array<vector<bool>, 2> used;
  used[0].resize(movesL);
  used[1].resize(movesR);
  vector<pair<int, int>> order;
  string play = "xo";

  auto Gen = [&](auto gen, int curCoup, int joueur) -> bool {
    if (curCoup == movesL + movesR) {
      cout << "TAK\n";
      for (auto [y, x] : order)
        cout << y + 1 << ' ' << x + 1 << '\n';
      return true;
    }

    for (int iCoup = 0; iCoup < (int)moves[joueur].size(); ++iCoup) {
      if (used[joueur][iCoup])
        continue;
      auto [lig, col] = moves[joueur][iCoup];
      grid[lig][col] = play[joueur];
      order.emplace_back(lig, col);
      used[joueur][iCoup] = true;
      if ((curCoup + 1 == movesL + movesR and
           (checkWin(lig, col) or dim * dim == curCoup + 1)) or
          (curCoup + 1 < movesL + movesR and !checkWin(lig, col)))
        if (gen(gen, curCoup + 1, !joueur))
          return true;
      used[joueur][iCoup] = false;
      grid[lig][col] = '.';
      order.pop_back();
    }
    return false;
  };

  if (!Gen(Gen, 0, 0) and !Gen(Gen, 0, 1))
    cout << "NIE\n";
}

signed main(void) {
  ios_base::sync_with_stdio(false);
  cin.tie(0);

  int nbTests;
  cin >> nbTests;
  for (int iTest(0); iTest < nbTests; ++iTest)
    solve();
}