#pragma GCC optimize("O3")
#pragma GCC optimize ("unroll-loops")
#pragma GCC optimize ("Ofast,no-stack-protector", "omit-frame-pointer", "inline", "-ffast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,sse4.2,fma,popcnt,abm,mmx,avx")

#include<bits/stdc++.h>

#define ll long long
#define pp push_back
#define endl '\n'
#define all(x) x.begin(),x.end()
#define ld long double
#define PI acos(-1)
#define sin(a) sin((a)*PI/180)
#define cos(a) cos((a)*PI/180)
#define ones(x) __builtin_popcountll(x)
//#define int ll

using namespace std;

void Drakon() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
#ifdef Clion
    freopen("input.txt", "r", stdin), freopen("output.txt", "w", stdout);
#endif
}

unsigned long long inf = 1e10;
const double EPS = 1e-6;
const int MOD = 1000000007, N = 30, LOG = 25;

ll gcd(ll x, ll y) {
    return y ? gcd(y, x % y) : x;
}

ll lcm(ll a, ll b) {
    return (a * b) / __gcd(a, b);
}

ll mul(const ll &a, const ll &b) {
    return (a % MOD + MOD) * (b % MOD + MOD) % MOD;
}

ll add(const ll &a, const ll &b) {
    return (a + b + 2 * MOD) % MOD;
}

ll pw(ll x, ll y) {
    ll ret = 1;
    while (y > 0) {
        if (y % 2 == 0) {
            x = mul(x, x);
            y = y / 2;
        } else {
            ret = mul(ret, x);
            y = y - 1;
        }
    }
    return ret;
}

int h, w, r, s;
char arr[N][N];
pair<int, int>top, bot;
vector<pair<pair<int, int>, double>>adj[N][N];

void dijkstra(){
    double dist[h][w][(h + w) * 9];
    for (int i = 0; i < h; ++i) {
        for (int j = 0; j < w; ++j) {
            for (int k = 0; k < (h + w) * 9; ++k) {
                dist[i][j][k] = 1e9;
            }
        }
    }

    dist[bot.first][bot.second][min(s, (h + w) * 9 - 1)] = 0;
    priority_queue<pair<pair<double, int>, pair<int, int>>, vector<pair<pair<double, int>, pair<int, int>>>, greater<>>q;
    q.push({{0, min(s - (arr[bot.first][bot.second] - '0'), (h + w) * 9 - 1)}, bot});
    while (!q.empty()){
        auto p = q.top();
        q.pop();
        int x = p.second.first, y = p.second.second, sta = p.first.second;
        double d = p.first.first;
        if(d - dist[x][y][sta] > EPS)continue;
        for(auto v : adj[x][y]){
            if(sta >= arr[v.first.first][v.first.second] - '0'){
                if(dist[v.first.first][v.first.second][sta - (arr[v.first.first][v.first.second] - '0')] - (d + v.second) > EPS){
                    dist[v.first.first][v.first.second][sta - (arr[v.first.first][v.first.second] - '0')] = d + v.second;
                    q.push({{d + v.second, sta - (arr[v.first.first][v.first.second] - '0')}, v.first});
                }
            }
        }
    }

    double ans = 1e9;
    for (int i = 0; i <= min(s, (h + w) * 9 - 1); ++i) {
        ans = min(ans, dist[top.first][top.second][i]);
    }
    if(ans > 1e8){
        cout << "impossible";
        return;
    }
    cout << fixed << setprecision(10) << ans;
}

void solve() {
    cin >> h >> w >> r >> s;
    for (int i = 0; i < h; ++i) {
        for (int j = 0; j < w; ++j) {
            cin >> arr[i][j];
        }
    }

    bool found = false;
    for (int i = 0; i < h; ++i) {
        for (int j = 0; j < w; ++j) {
            if(arr[i][j] != '.'){
                top = {i, j};
                found = true;
                break;
            }
        }
        if(found)break;
    }

    found = false;
    for (int i = h - 1; i >= 0; --i) {
        for (int j = 0; j < w; ++j) {
            if(arr[i][j] != '.'){
                bot = {i, j};
                found = true;
                break;
            }
        }
        if(found)break;
    }

    for (int i = 0; i < h; ++i) {
        for (int j = 0; j < w; ++j) {
            if(arr[i][j] == '.')continue;
            for (int k = 0; k < h; ++k) {
                for (int l = 0; l < w; ++l) {
                    if(k == i && l == j)continue;
                    if(arr[k][l] == '.')continue;;
                    int d = (i - k) * (i - k) + (j - l) * (j - l);
                    if(d <= r * r){
                        adj[i][j].pp({{k, l}, sqrt(d)});
                    }
                }
            }
        }
    }

    dijkstra();
}

signed main() {
    Drakon();
    int t = 1;
    //cin >> t;
    while (t--) {
        solve();
    }
}