use std::cmp;
use std::collections::BinaryHeap;

const INF: u32 = 1e9 as u32;
const DIR: [(i32, i32); 4] = [(0, -1), (0, 1), (-1, 0), (1, 0)];

#[derive(Copy, Clone, Eq, PartialEq, Debug)]
struct State {
    turn: u32,
    open: u32,
    step: u32,
}

impl Ord for State {
    fn cmp(&self, other: &State) -> std::cmp::Ordering {
        let other = (other.turn, other.open, other.step);
        let s = (self.turn, self.open, self.step);
        other.cmp(&s)
    }
}

impl PartialOrd for State {
    fn partial_cmp(&self, other: &State) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

fn main() {
    let s = std::io::stdin();
    let mut sc = Scanner { stdin: s.lock() };
    let h: usize = sc.read();
    let w: usize = sc.read();
    let k: u32 = sc.read();
    let board: Vec<_> = (0..h).map(|_| sc.chars()).collect();
    let mut dist = vec![
        vec![
            State {
                turn: INF,
                open: INF,
                step: INF
            };
            w
        ];
        h
    ];

    let mut q = BinaryHeap::new();
    for i in 0..h {
        for j in 0..w {
            if board[i][j] == 'S' {
                dist[i][j] = State {
                    turn: 0,
                    open: 0,
                    step: 0,
                };
                q.push((dist[i][j], i, j));
            }
        }
    }

    while let Some((State { turn, open, step }, i, j)) = q.pop() {
        if i == 0 || i == h - 1 || j == 0 || j == w - 1 {
            println!("{}", turn);
            return;
        }
        for (di, dj) in DIR.iter().cloned() {
            let ni = (i as i32) + di;
            let nj = (j as i32) + dj;
            if ni < 0 || nj < 0 {
                continue;
            }
            let ni = ni as usize;
            let nj = nj as usize;
            if ni >= h || nj >= w {
                continue;
            }

            let next_step = step + 1;
            let next_open = if board[ni][nj] == '#' { open + 1 } else { open };
            let next_turn = cmp::max((next_step + k - 1) / k, (next_open + k - 1) / k + 1);
            let next_state = State {
                turn: next_turn,
                open: next_open,
                step: next_step,
            };
            if dist[ni][nj] < next_state {
                dist[ni][nj] = next_state;
                q.push((next_state, ni, nj));
            }
        }
    }
}

pub struct Scanner<R> {
    stdin: R,
}

impl<R: std::io::Read> Scanner<R> {
    pub fn read<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let buf = self
            .stdin
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r')
            .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r')
            .collect::<Vec<_>>();
        unsafe { std::str::from_utf8_unchecked(&buf) }
            .parse()
            .ok()
            .expect("Parse error.")
    }
    pub fn vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read()).collect()
    }
    pub fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}
