#include <bits/stdc++.h>
using namespace std;
int k;
int n;
int rowDeltas[] = {0, 1};
int colDeltas[] = {1, 0};
const int DIR_COUNT = 2;
class Cell {
 public:
  int rowIndex;
  int colIndex;
  char color;
  char state;
  int associatedPathCount;
  Cell(int r, int c, char s) {
    rowIndex = r;
    colIndex = c;
    color = 'w';
    state = s;
    associatedPathCount = 0;
  }
  bool isProbablePartOfShip() { return state == '.'; }
};
bool isWithinBoundary(int rowIndex, int colIndex) {
  return (0 <= rowIndex && rowIndex < n) && (0 <= colIndex && colIndex < n);
}
int main() {
  cin >> n;
  cin >> k;
  cin.ignore();
  int maxTraversedCount = 0;
  Cell *maxTraversedCell = NULL;
  Cell ***grid = new Cell **[n];
  for (int RI = 0; RI < n; RI++) {
    string data;
    getline(cin, data);
    grid[RI] = new Cell *[n];
    for (int CI = 0; CI < n; CI++) {
      grid[RI][CI] = new Cell(RI, CI, data[CI]);
    }
  }
  for (int RI = 0; RI < n; RI++) {
    for (int CI = 0; CI < n; CI++) {
      Cell *cell = grid[RI][CI];
      if (!cell->isProbablePartOfShip()) {
        continue;
      }
      for (int DI = 0; DI < DIR_COUNT; DI++) {
        bool isComplete = true;
        for (int KI = 0; KI < k; KI++) {
          int newRowIndex = cell->rowIndex + (rowDeltas[DI] * KI);
          int newColIndex = cell->colIndex + (colDeltas[DI] * KI);
          if (isWithinBoundary(newRowIndex, newColIndex)) {
            Cell *traversedCell = grid[newRowIndex][newColIndex];
            if (!traversedCell->isProbablePartOfShip()) {
              isComplete = false;
              break;
            }
          } else {
            isComplete = false;
            break;
          }
        }
        if (isComplete) {
          for (int KI = 0; KI < k; KI++) {
            int newRowIndex = cell->rowIndex + (rowDeltas[DI] * KI);
            int newColIndex = cell->colIndex + (colDeltas[DI] * KI);
            Cell *traversedCell = grid[newRowIndex][newColIndex];
            traversedCell->associatedPathCount++;
            if (traversedCell->associatedPathCount > maxTraversedCount) {
              maxTraversedCount = traversedCell->associatedPathCount;
              maxTraversedCell = traversedCell;
            }
          }
        }
      }
    }
  }
  if (maxTraversedCell != NULL) {
    cout << (maxTraversedCell->rowIndex + 1) << " "
         << (maxTraversedCell->colIndex + 1);
  } else {
    cout << 1 << " " << 1;
  }
  for (int RI = 0; RI < n; RI++) {
    for (int CI = 0; CI < n; CI++) {
      delete grid[RI][CI];
    }
    delete[] grid[RI];
  }
  delete[] grid;
  return 0;
}
