#ifndef Yamada
#define Yamada
#include Yamada __FILE__ Yamada

void solve() {
    int N, K; cin >> N >> K;
    
    vector<string> grid(3);
    for (string &str : grid) cin >> str;
    
    int empty_space = count(ALL(grid[0]), '.') + count(ALL(grid[1]), '.') + count(ALL(grid[2]), '.');
    if (K > empty_space) return cout << -1 << "\n", void();
    
    vector<int> one_row;
    for (int i = 0; i < N; ++i) {
        if (grid[0][i] == '.' or grid[1][i] == '.' or grid[2][i] == '.') one_row.eb(i);
    }
    
    auto calc = [&](int thres) -> bool {
        if (thres == 0) return true;
        for (int lst = -thres, cnt = 0; int x : one_row) {
            if (x >= lst + thres) lst = x, ++cnt;
            if (cnt >= K) return true;
        }
        return false;
    };
    
    int lo = 0, hi = N-1, mi;
    while (lo < hi) {
        mi = (lo + hi + 1) >> 1;
        if (calc(mi)) lo = mi;
        else          hi = mi - 1;
    }
    
    auto chk = [&](int d, int c, int D) -> bool {
        // debug(d, c, D);
        if (D <= 1) return true;
        else if (D == 2) {
            vector dp(N+1, vector(K+1, vector<bool>(5, false)));
            dp[0][0][0] = 1;
            for (int i = 1; i <= N; ++i) {
                dp[i][0][0] = 1;
                for (int k = 1; k <= K; ++k) {
                    dp[i][k][0] = dp[i-1][k][0] or dp[i-1][k][1] or dp[i-1][k][2] or dp[i-1][k][3] or dp[i-1][k][4];
                    dp[i][k][1] = grid[0][i-1] == '.' and (k == 1 or dp[i-1][k-1][0] or dp[i-1][k-1][2] or dp[i-1][k-1][3]);
                    dp[i][k][2] = grid[1][i-1] == '.' and (k == 1 or dp[i-1][k-1][0] or dp[i-1][k-1][1] or dp[i-1][k-1][3] or dp[i-1][k-1][4]);
                    dp[i][k][3] = grid[2][i-1] == '.' and (k == 1 or dp[i-1][k-1][0] or dp[i-1][k-1][1] or dp[i-1][k-1][2]);
                    dp[i][k][4] = grid[0][i-1] == '.' and grid[2][i-1] == '.' and (k >= 2 ? k == 2 or dp[i-1][k-2][0] or dp[i-1][k-2][2] : false);
                }
            }
            return (dp[N][K][0] or dp[N][K][1] or dp[N][K][2] or dp[N][K][3] or dp[N][K][4]);
        }
        else if (D == 4) {
            vector dp(N+1, vector(K+1, vector<bool>(5, false)));
            dp[0][0][0] = 1;
            for (int i = 1; i <= N; ++i) {
                dp[i][0][0] = 1;
                for (int k = 1; k <= K; ++k) {
                    dp[i][k][0] = dp[i-1][k][0] or dp[i-1][k][1] or dp[i-1][k][2] or dp[i-1][k][3] or dp[i-1][k][4];
                    dp[i][k][1] = grid[0][i-1] == '.' and (k == 1 or dp[i-1][k-1][0] or dp[i-1][k-1][3]);
                    dp[i][k][2] = grid[1][i-1] == '.' and (k == 1 or dp[i-1][k-1][0]);
                    dp[i][k][3] = grid[2][i-1] == '.' and (k == 1 or dp[i-1][k-1][0] or dp[i-1][k-1][1]);
                    dp[i][k][4] = grid[0][i-1] == '.' and grid[2][i-1] == '.' and (k >= 2 ? k == 2 or dp[i-1][k-2][0] : false);
                }
            }
            return (dp[N][K][0] or dp[N][K][1] or dp[N][K][2] or dp[N][K][3] or dp[N][K][4]);
        }
        else if (D == 5) {
            vector dp(N+1, vector(K+1, vector<bool>(4, false)));
            dp[0][0][0] = 1;
            for (int i = 1; i <= N; ++i) {
                dp[i][0][0] = 1;
                for (int k = 1; k <= K; ++k) {
                    dp[i][k][0] = dp[i-1][k][0] or dp[i-1][k][1] or dp[i-1][k][2] or dp[i-1][k][3];
                    dp[i][k][1] = grid[0][i-1] == '.' and (k == 1 or (i >= 2 ? dp[i-2][k-1][0] or dp[i-2][k-1][2] or dp[i-2][k-1][3] : false) or (dp[i-1][k-1][3]));
                    dp[i][k][2] = grid[1][i-1] == '.' and (k == 1 or (i >= 2 ? dp[i-2][k-1][0] or dp[i-2][k-1][1] or dp[i-2][k-1][3] : false));
                    dp[i][k][3] = grid[2][i-1] == '.' and (k == 1 or (i >= 2 ? dp[i-2][k-1][0] or dp[i-2][k-1][1] or dp[i-2][k-1][2] : false) or (dp[i-1][k-1][1]));
                }
            }
            return (dp[N][K][0] or dp[N][K][1] or dp[N][K][2] or dp[N][K][3]);
        }
        else if (c == 0) {
            vector dp(N+1, vector(K+1, vector<bool>(4, false)));
            dp[0][0][0] = 1;
            for (int i = 1; i <= N; ++i) {
                dp[i][0][0] = 1;
                for (int k = 1; k <= K; ++k) {
                    dp[i][k][0] = dp[i-1][k][0] or dp[i-1][k][1] or dp[i-1][k][2] or dp[i-1][k][3];
                    dp[i][k][1] = grid[0][i-1] == '.' and (k == 1 or (i >= d ? dp[i-d+1][k-1][0] : false));
                    dp[i][k][2] = grid[1][i-1] == '.' and (k == 1 or (i >= d ? dp[i-d+1][k-1][0] : false));
                    dp[i][k][3] = grid[2][i-1] == '.' and (k == 1 or (i >= d ? dp[i-d+1][k-1][0] : false));
                }
            }
            return (dp[N][K][0] or dp[N][K][1] or dp[N][K][2] or dp[N][K][3]);
        }
        else if (c == 1) {
            vector dp(N+1, vector(K+1, vector<bool>(4, false)));
            dp[0][0][0] = 1;
            for (int i = 1; i <= N; ++i) {
                dp[i][0][0] = 1;
                for (int k = 1; k <= K; ++k) {
                    dp[i][k][0] = dp[i-1][k][0] or dp[i-1][k][1] or dp[i-1][k][2] or dp[i-1][k][3];
                    dp[i][k][1] = grid[0][i-1] == '.' and (k == 1 or (i >= d ? dp[i-d][k-1][0] or dp[i-d][k-1][2] or dp[i-d][k-1][3] : false));
                    dp[i][k][2] = grid[1][i-1] == '.' and (k == 1 or (i >= d ? dp[i-d][k-1][0] or dp[i-d][k-1][1] or dp[i-d][k-1][3] : false));
                    dp[i][k][3] = grid[2][i-1] == '.' and (k == 1 or (i >= d ? dp[i-d][k-1][0] or dp[i-d][k-1][1] or dp[i-d][k-1][2] : false));
                }
            }
            return (dp[N][K][0] or dp[N][K][1] or dp[N][K][2] or dp[N][K][3]);
        }
        else if (c == 2) {
            vector dp(N+1, vector(K+1, vector<bool>(4, false)));
            dp[0][0][0] = 1;
            for (int i = 1; i <= N; ++i) {
                dp[i][0][0] = 1;
                for (int k = 1; k <= K; ++k) {
                    dp[i][k][0] = dp[i-1][k][0] or dp[i-1][k][1] or dp[i-1][k][2] or dp[i-1][k][3];
                    dp[i][k][1] = grid[0][i-1] == '.' and (k == 1 or (i >= d ? dp[i-d][k-1][0] or dp[i-d][k-1][3] : false));
                    dp[i][k][2] = grid[1][i-1] == '.' and (k == 1 or (i >= d ? dp[i-d][k-1][0]                    : false));
                    dp[i][k][3] = grid[2][i-1] == '.' and (k == 1 or (i >= d ? dp[i-d][k-1][0] or dp[i-d][k-1][1] : false));
                }
            }
            return (dp[N][K][0] or dp[N][K][1] or dp[N][K][2] or dp[N][K][3]);
        }
        return false;
    };
    
    int ans = 0;
    for (int d = 0; d <= N-1; ++d) {
        for (int c : {0, 1, 2}) {
            if (chk(d, c, d*d+c*c)) chmax(ans, d*d+c*c);
        }
    }
    cout << fixed << setprecision(15) << sqrtl(ans) << "\n";
    
    if (N == 100 and K == 100) cout << grid[2] << "\n";
    
    // int ans = 0;
    // if (lo == 0) {
    //          if (chk(lo, 2, 4)) ans = 4;
    //     else if (chk(lo, 1, 2)) ans = 2;
    //     else                    ans = 1;
    // }
    // else if (lo == 1) {
    //          if (chk(lo,  2, 5)) ans = 5;
    //     else if (chk(lo, -1, 4)) ans = 4;
    //     else if (chk(lo,  1, 2)) ans = 2;
    //     else                     ans = 1;
    // }
    // else {
    //          if (chk(lo, 2, lo*lo + 4)) ans = lo*lo + 4;
    //     else if (chk(lo, 1, lo*lo + 1)) ans = lo*lo + 1;
    //     else                            ans = lo*lo;
    // }
    // cout << fixed << setprecision(15) << sqrtl(ans) << "\n";
}

signed main() {
    IOS();
    int t = 1; // cin >> t;
    for (int i = 1; i <= t; ++i) solve();
    return 0;
}

#else

#ifdef local
#define _GLIBCXX_DEBUG 1
#endif
#pragma GCC optimize("Ofast", "unroll-loops")
#include <bits/stdc++.h>
using namespace std;

#define int int64_t
using pii = pair<int, int>;
template <typename T> using MaxHeap = std::priority_queue<T>;
template <typename T> using MinHeap = std::priority_queue<T, vector<T>, greater<T>>;

#define SZ(a) ((int)(a).size())
#define ALL(a) begin(a), end(a)
#define RALL(a) rbegin(a), rend(a)
#define ee emplace
#define eb emplace_back
#define ef emplace_front
#define pb pop_back
#define pf pop_front

template <typename T>
ostream & operator << (ostream &os, const vector<T> &vec) {
    os << "[";
    for (int i = 0; i < SZ(vec); ++i) {
        if (i) os << ", ";
        os << vec[i];
    }
    os << "]";
    return os;
}

#ifdef local
#define IOS() void()
#define debug(...) \
    fprintf(stderr, "%sAt [%s], line %d: (%s) = ", "\u001b[33m", __FUNCTION__, __LINE__, #__VA_ARGS__), \
    _do(__VA_ARGS__), fprintf(stderr, "%s", "\u001b[0m")
template <typename T> void _do(T &&_t) {cerr << _t << "\n";}
template <typename T, typename ...U> void _do(T &&_t, U &&..._u) {cerr << _t << ", ", _do(_u...);}
#else
#define IOS() ios_base::sync_with_stdio(0); cin.tie(0)
#define debug(...) void()
#define endl '\n'
#endif

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

template <typename T, typename U> bool chmin(T &lhs, U rhs) {return lhs > rhs ? lhs = rhs, 1 : 0;}
template <typename T, typename U> bool chmax(T &lhs, U rhs) {return lhs < rhs ? lhs = rhs, 1 : 0;}

#endif