#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
using ll = long long int;
const ll MD = 1000000007ll;
const long double PI = 3.1415926535897932384626433832795L;
inline void assert_call(bool assertion, function<void()> f) {
  if (!assertion) {
    cerr << "assertion fault:" << endl;
    f();
    abort();
  }
}
template <typename T1, typename T2>
inline ostream& operator<<(ostream& o, const pair<T1, T2> p) {
  o << '(' << p.first << ':' << p.second << ')';
  return o;
}
template <typename Vec>
inline ostream& _ostream_vecprint(ostream& os, const Vec& a) {
  os << '[';
  for (const auto& e : a) os << ' ' << e << ' ';
  os << ']';
  return os;
}
template <typename T>
inline ostream& operator<<(ostream& o, const vector<T>& v) {
  return _ostream_vecprint(o, v);
}
template <typename T, size_t S>
inline ostream& operator<<(ostream& o, const array<T, S>& v) {
  return _ostream_vecprint(o, v);
}
template <typename T>
inline T& chmax(T& to, const T& val) {
  return to = max(to, val);
}
template <typename T>
inline T& chmin(T& to, const T& val) {
  return to = min(to, val);
}
void bye(string s, int code = 0) {
  cout << s << endl;
  exit(code);
}
mt19937_64 randdev(8901016);
template <typename T>
inline T rand(T l, T h) {
  return uniform_int_distribution<T>(l, h)(randdev);
}
template <>
inline double rand<double>(double l, double h) {
  return uniform_real_distribution<double>(l, h)(randdev);
}
template <>
inline float rand<float>(float l, float h) {
  return uniform_real_distribution<float>(l, h)(randdev);
}
namespace {
class MaiScanner {
 public:
  template <typename T>
  void input_integer(T& var) {
    var = 0;
    T sign = 1;
    int cc = getchar_unlocked();
    for (; cc < '0' || '9' < cc; cc = getchar_unlocked())
      if (cc == '-') sign = -1;
    for (; '0' <= cc && cc <= '9'; cc = getchar_unlocked())
      var = (var << 3) + (var << 1) + cc - '0';
    var = var * sign;
  }
  inline int c() { return getchar_unlocked(); }
  inline MaiScanner& operator>>(int& var) {
    input_integer<int>(var);
    return *this;
  }
  inline MaiScanner& operator>>(long long& var) {
    input_integer<long long>(var);
    return *this;
  }
  inline MaiScanner& operator>>(string& var) {
    int cc = getchar_unlocked();
    for (; !(0x21 <= (cc) && (cc) <= 0x7E); cc = getchar_unlocked())
      ;
    for (; (0x21 <= (cc) && (cc) <= 0x7E); cc = getchar_unlocked())
      var.push_back(cc);
    return *this;
  }
  template <typename IT>
  void in(IT begin, IT end) {
    for (auto it = begin; it != end; ++it) *this >> *it;
  }
};
class MaiPrinter {
 public:
  template <typename T>
  void output_integer(T var) {
    if (var == 0) {
      putchar_unlocked('0');
      return;
    }
    if (var < 0) putchar_unlocked('-'), var = -var;
    char stack[32];
    int stack_p = 0;
    while (var) stack[stack_p++] = '0' + (var % 10), var /= 10;
    while (stack_p) putchar_unlocked(stack[--stack_p]);
  }
  inline MaiPrinter& operator<<(char c) {
    putchar_unlocked(c);
    return *this;
  }
  inline MaiPrinter& operator<<(int var) {
    output_integer<int>(var);
    return *this;
  }
  inline MaiPrinter& operator<<(long long var) {
    output_integer<long long>(var);
    return *this;
  }
  inline MaiPrinter& operator<<(char* str_p) {
    while (*str_p) putchar_unlocked(*(str_p++));
    return *this;
  }
  inline MaiPrinter& operator<<(const string& str) {
    const char* p = str.c_str();
    const char* l = p + str.size();
    while (p < l) putchar_unlocked(*p++);
    return *this;
  }
  template <typename IT>
  void join(IT begin, IT end, char sep = ' ') {
    for (bool b = 0; begin != end; ++begin, b = 1)
      b ? *this << sep << *begin : *this << *begin;
  }
};
}  // namespace
MaiScanner scanner;
MaiPrinter printer;
struct P {
  using T = int;
  T y, x;
  P(T _y = 0, T _x = 0) : y(_y), x(_x) {}
  inline bool operator==(P p) const { return y == p.y && x == p.x; }
  inline bool operator<(P p) const { return y == p.y ? x < p.x : y < p.y; }
  inline P operator+(P p) const { return P(y + p.y, x + p.x); }
  inline P operator-(P p) const { return P(y - p.y, x - p.x); }
  inline P operator+=(P p) {
    y += p.y;
    x += p.x;
    return *this;
  }
  inline P operator-=(P p) {
    y -= p.y;
    x -= p.x;
    return *this;
  }
};
inline ostream& operator<<(ostream& os, P p) {
  os << '(' << p.y << ',' << p.x << ')';
  return os;
}
const P FourMoving[] = {P(-1, 0), P(0, 1), P(1, 0), P(0, -1)};
const P FiveMoving[] = {P(-1, 0), P(0, 1), P(1, 0), P(0, -1), P(0, 0)};
const P EightMoving[] = {P(-1, 0),  P(0, 1),  P(1, 0),  P(0, -1),
                         P(-1, -1), P(-1, 1), P(1, -1), P(1, 1)};
int H, W, K, HW;
P start;
string A[801];
int dp[801][801];
int main() {
  scanner >> H >> W >> K;
  HW = H * W;
  for (remove_reference<remove_const<decltype(H)>::type>::type i = 0; (i) < (H);
       ++(i)) {
    scanner >> A[i];
    for (remove_reference<remove_const<decltype(W)>::type>::type j = 0;
         (j) < (W); ++(j)) {
      if (A[i][j] == 'S') {
        start.y = i;
        start.x = j;
        A[i][j] = '.';
        break;
      }
    }
  }
  fill(dp[0], dp[H], int(1e9));
  dp[start.y][start.x] = 0;
  queue<P> que;
  que.emplace(start);
  int best = 1e9;
  while (!que.empty()) {
    P p = que.front();
    que.pop();
    if (p.y == 0 || p.x == 0 || p.y == H - 1 || p.x == W - 1) {
      break;
    }
    int currcost = dp[p.y][p.x];
    for (auto mv : FourMoving) {
      P p2 = p + mv;
      int c = currcost + 1;
      if (A[p2.y][p2.x] == '#') continue;
      if (dp[p2.y][p2.x] > c) {
        dp[p2.y][p2.x] = c;
        que.push(p2);
      }
    }
  }
  for (remove_reference<remove_const<decltype(H)>::type>::type i = 0; (i) < (H);
       ++(i)) {
    for (remove_reference<remove_const<decltype(W)>::type>::type j = 0;
         (j) < (W); ++(j)) {
      if (dp[i][j] > 1e8) continue;
      int m = min(min(min(H - i - 1, i), W - j - 1), j);
      chmin(best, 1 + (m + (K)-1) / (K));
    }
  }
  cout << best << endl;
  return 0;
}
