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

// [1] n-迷宫的列数；m-迷宫的行数；r-被困的勇士数量（不含国王）
int n,m,r;
// [2] a,b-起点S的坐标（0-based）；c,d-终点E的坐标（0-based）
int a,b,c,d;
// [3] arr数组-存储迷宫地图（#墙、.通路、S起点、E终点）
char arr[510][510];
// [4] dp数组-存储每个点到起点S的最短距离（0表示未访问/不可达）
int dp[510][510]={};

// [5] 队列存储的坐标结构体（用于BFS遍历节点）
struct stu{
    int x,y;
};
queue<stu> q;  // [6] BFS队列，存储待处理的节点坐标

// [7] 四个方向的偏移量（下、上、右、左）
int dx[4]={1,-1,0,0};
int dy[4]={0,0,1,-1};

void bfs(){
    // 1. 起点入队
    q.push({a,b});
    // 起点的距离为0（已初始化），标记为已访问（修改为*避免重复入队）
    arr[a][b]='*';

    // 2. 处理队列中的节点（BFS核心循环）
    while(!q.empty()){
        stu e=q.front();
        q.pop();
        // 提前终止：如果当前节点是终点，直接返回（BFS首次到达即为最短路径）
        if(e.x==c && e.y==d){
            return;
        }

        // 遍历四个方向的邻居节点
        for(int i=0;i<4;i++){
            int tx=e.x+dx[i];  // [8] 计算邻居节点的横坐标
            int ty=e.y+dy[i];  // [9] 计算邻居节点的纵坐标
            // 合法性判断：1.坐标在迷宫范围内；2.是通路（.）或终点（E）；3.未被访问（arr[tx][ty]未被修改为*）
            if((tx>=0 && tx<m) && (ty>=0 && ty<n) && (arr[tx][ty]=='.' || arr[tx][ty]=='E')){
                dp[tx][ty]=dp[e.x][e.y]+1;  // [10] 更新邻居节点的距离（当前节点距离+1）
                arr[tx][ty]='*';  // [11] 标记邻居节点为已访问（避免重复入队）
                q.push({tx,ty});  // [12] 邻居节点入队
            }
        } 
    }
}

int main() {
    cin>>m>>n>>r;  // [13] 读取迷宫的行数m、列数n、勇士数量r
    // 读取迷宫地图，并记录起点S和终点E的坐标
    for(int i=0;i<m;i++){
        for(int j=0;j<n;j++){
            cin>>arr[i][j];
            if(arr[i][j]=='S'){
                a=i;
                b=j;
            } 
            if(arr[i][j]=='E'){
                c=i;
                d=j;
            }	
        }
    }
    bfs();  // [14] 调用BFS寻找S到E的最短路径

    // 输出结果：如果终点距离为0（未找到路径）输出-1，否则输出总时间（单个勇士时间×勇士数量）
    if(dp[c][d]==0) cout<<-1;
    else cout<<dp[c][d]*r;
    return 0;
}