use std::cmp::min;
use std::collections::VecDeque;
use std::io::*;
use std::str::FromStr;

fn main() {
    let (h, w, k): (usize, usize, usize) = (read(), read(), read());
    let a: Vec<Vec<char>> = (0..h).map(|_| read::<String>().chars().collect()).collect();
    let mut s: (usize, usize) = (0, 0);
    for i in 0..h {
        for j in 0..w {
            if a[i][j] == 'S' {
                s = (i, j);
            }
        }
    }

    let mut que: VecDeque<(usize, usize)> = VecDeque::new();
    let inf: i64 = 1 << 62;
    let mut d: Vec<Vec<i64>> = vec![vec![inf; w]; h];
    que.push_back(s);
    d[s.0][s.1] = 0;
    let (dx, dy) = ([0, 0, 1, -1], [1, -1, 0, 0]);
    let mut ans = h * w;
    while !que.is_empty() {
        let (y, x) = que.pop_front().unwrap();
        ans = min(ans, min(min(x, w - x - 1), min(y, h - y - 1)));
        if d[y][x] == k as i64 {
            continue;
        }
        for i in 0..4 {
            let (ny, nx) = (y as i64 + dy[i], x as i64 + dx[i]);
            if 0 > nx || 0 > ny {
                continue;
            }
            let (nx, ny) = (nx as usize, ny as usize);
            if nx >= h || ny >= w || d[ny][nx] != inf || a[ny][nx] == '#' {
                continue;
            }
            d[ny][nx] = d[y][x] + 1;
            que.push_back((ny, nx));
        }
    }
    println!("{}", 1 + if ans % k == 0 { ans / k } else { ans / k + 1 });
}

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}
