#include <bits/stdc++.h>
#define lp(i,a,b) for(int i=(a);i<(b);++i)
#define pii pair<int,int>
#define pb push_back
#define ins insert
#define fi first
#define se second
#define opa(x) cerr << #x << " = " << x << ", ";
#define op(x) cerr << #x << " = " << x << endl;
#define ops(x) cerr << x;
#define opL cerr << "Ln " << __LINE__ << '\n';
#define etr cerr << endl;
#define spc cerr << ' ';
#define all(x) (x).begin(), (x).end()
#define STL(x) cerr << #x << " : "; for(auto &qwe:x) cerr << qwe << ' '; cerr << endl;
#define bye exit(0);
using namespace std;
mt19937 rngf(chrono::steady_clock().now().time_since_epoch().count());
inline int rng(int l, int r){ return uniform_int_distribution<int>(l, r)(rngf); }

const int mxN = 128;
const int INF = (int)(1e9 + 10);
int n, k;
bool can[mxN][3];

#pragma GCC optimize("O3", "unroll-loops")
#define chmax(x, y) x = max(x, y)
#define sq(x) ((x) * (x))
#define popcnt(x) __builtin_popcount(x)

bool check_small(int d) {
    auto match = [&](int i, int ptrn) {
        for (int j = 0; j < 3; ++j) {
            if (((ptrn >> j) & 1) && (!can[i][j])) return false;
        }
        for (int j = 0; j < 3; ++j) {
            for (int k = j + 1; k < 3; ++k) {
                if (((ptrn >> j) & 1) && ((ptrn >> k) & 1) && sq(j - k) < d) {
                    return false;
                }
            }
        }
        return true;
    };
    auto enough_distance = [&](int ptrn1, int ptrn2) {
        for (int j = 0; j < 3; ++j) {
            for (int k = 0; k < 3; ++k) {
                if (((ptrn1 >> j) & 1) && ((ptrn2 >> k) & 1) && 1 + sq(j - k) < d) {
                    return false;
                }
            }
        }
        return true;
    };
    vector<vector<int>> dp(mxN, vector<int>(8, -INF));
    for (int i = 0; i < n; ++i) {
        for (int ptrn = 0; ptrn < 8; ++ptrn) {
            if (!match(i, ptrn)) continue;
            chmax(dp[i][ptrn], popcnt(ptrn));
            if (i == 0) continue;
            for (int pre = 0; pre < 8; ++pre) {
                if (dp[i - 1][pre] < 0) continue;
                if (enough_distance(pre, ptrn)) {
                    chmax(dp[i][ptrn], dp[i - 1][pre] + popcnt(ptrn));
                }
            }
        }
    }
    int mx = -INF;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < 8; ++j) {
            chmax(mx, dp[i][j]);
        }
    }
    return (mx >= k);
}

bool check_big(int d) {
    auto match = [&](int i, int ptrn) {
        switch (ptrn) {
        case 0:
            return true;
        case 1:
            return can[i][0];
        case 2:
            return can[i][1];
        case 3:
            return can[i][2];
        case 4:
            return (d == 5 && can[i][0] && can[i + 1][2]);
        case 5:
            return (d == 5 && can[i][2] && can[i + 1][0]);
        }
        assert(false);
    };
    static vector<vector<pii>> dxdy = {{},
                                       {{0, 0}},
                                       {{0, 1}},
                                       {{0, 2}},
                                       {{0, 0}, {1, 2}},
                                       {{0, 2}, {1, 0}}
                                      };
    auto enough_distance = [&](int di, int j, int k) {
        for (auto &[i1, j1] : dxdy[j]) {
            for (auto &[i2, j2] : dxdy[k]) {
                if (sq(di - i1 + i2) + sq(j1 - j2) < d) return false;
            }
        }
        return true;
    };
    static vector<int> eggcnt = {0, 1, 1, 1, 2, 2};
    vector<vector<int>> dp(mxN, vector<int>(6, -INF));
    for (int i = 0; i < n; ++i) {
        // assume this is the first non-zero dp value
        for (int j = 1; j <= 5; ++j) {
            if (match(i, j)) {
                chmax(dp[i][j], eggcnt[j]);
            }
        }
        // try transfer from the back
        for (int p = i - 2; p >= 0; --p) {
            for (int j = 1; j <= 5; ++j) {
                if (dp[p][j] == -INF) continue;
                for (int k = 1; k <= 5; ++k) {
                    if (dp[p][j] + eggcnt[k] <= dp[i][k] || (!match(i, k))) continue;
                    if (enough_distance(i - p, j, k)) {
                        dp[i][k] = dp[p][j] + eggcnt[k];
                    }
                }
            }
        }
    }
    int mx = -INF;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j <= 5; ++j) {
            chmax(mx, dp[i][j]);
        }
    }
    return (mx >= k);
}

bool check(int d) {
    if (d <= 4) {
        return check_small(d);
    }
    else {
        return check_big(d);
    }
}

int main(){
    ios::sync_with_stdio(false); cin.tie(0);
    cin >> n >> k;
    int tot_spaces = 0;
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < n; ++j) {
            char c; cin >> c;
            can[j][i] = (c == '.');
            tot_spaces += (c == '.');
        }
    }
    if (tot_spaces < k) {
        cout << "-1\n";
        return 0;
    }
    int l = 1, r = n * n + 16, mid;
    while (l < r) {
        mid = (l + r + 1) >> 1;
        if (check(mid)) {
            l = mid;
        }
        else {
            r = mid - 1;
        }
    }
    long double ans = sqrt((long double)l);
    cout << fixed << setprecision(10) << ans << '\n';
}