#ifndef Yamada
#define Yamada
#include Yamada __FILE__ Yamada

const int maxn = 3 * 100 + 5;

struct GenMatch {
    int V, pr[maxn];
    bool el[maxn][maxn], inq[maxn], inp[maxn], inb[maxn];
    int st, ed, nb, bk[maxn], djs[maxn], ans;
    void init(int _V) {
        V = _V;
        for (int i = 0; i <= V; ++i) {
            for (int j = 0; j <= V; ++j) el[i][j] = 0;
            pr[i] = bk[i] = djs[i] = 0;
            inq[i] = inp[i] = inb[i] = 0;
        }
    }
    void add_edge(int u, int v) {
        el[u][v] = el[v][u] = 1;
    }
    int lca(int u, int v) {
        fill_n(inp, V+1, 0);
        while (1) {
            if (u = djs[u], inp[u] = true, u == st) break;
            else u = bk[pr[u]];
        }
        while (1) {
            if (v = djs[v], inp[v]) return v;
            else v = bk[pr[v]];
        }
        return v;
    }
    void upd(int u) {
        for (int v; djs[u] != nb; ) {
            v = pr[u], inb[djs[u]] = inb[djs[v]] = true;
            u = bk[v];
            if (djs[u] != nb) bk[u] = v;
        }
    }
    void blo(int u, int v, queue<int> &qe) {
        nb = lca(u, v), fill_n(inb, V+1, 0);
        upd(u), upd(v);
        if (djs[u] != nb) bk[u] = v;
        if (djs[v] != nb) bk[v] = u;
        for (int tu = 1; tu <= V; ++tu) {
            if (inb[djs[tu]]) {
                if (djs[tu] = nb, !inq[tu]) qe.push(tu), inq[tu] = 1;
            }
        }
    }
    void flow() {
        fill_n(inq+1, V, 0), fill_n(bk+1, V, 0);
        iota(djs+1, djs+V+1, 1);
        queue<int> qe; qe.push(st), inq[st] = 1, ed = 0;
        while (!qe.empty()) {
            int u = qe.front(); qe.pop();
            for (int v = 1; v <= V; ++v) {
                if (el[u][v] and djs[u] != djs[v] and pr[u] != v) {
                    if ((v == st) or (pr[v] > 0 and bk[pr[v]] > 0)) blo(u, v, qe);
                    else if (!bk[v]) {
                        if (bk[v] = u, pr[v] > 0) {if (!inq[pr[v]]) qe.push(pr[v]);}
                        else return ed = v, void();
                    }
                }
            }
        }
    }
    void aug() {
        for (int u = ed, v, w; u > 0; ) {
            v = bk[u], w = pr[v], pr[v] = u, pr[u] = v;
            u = w;
        }
    }
    int solve() {
        fill_n(pr, V+1, 0), ans = 0;
        for (int u = 1; u <= V; ++u) {
            if (!pr[u]) {
                if (st = u, flow(), ed > 0) aug(), ++ans;
            }
        }
        return ans;
    }
};

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 == 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 == 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;
    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