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

const int N = 128;
int n, k;
const int L = 4;

const int64_t INF = 1e16;

int64_t dp[N][3 * N][L * L *L];
string s[3];
pair <int, int64_t> precomp[N][L * L * L][N][8];
int cnt[8];
constexpr pair <int, int64_t> INVALID = make_pair(-1, int64_t(-1));

int compress(int a, int b, int c) {
	return L * L * a + L * b + c;
}

int compress(array <int, 3> a) {
	return L * L * a[0] + L * a[1] + a[2];
}

int compress(array <int, 3> lst, int pa, array <int, 3> nxt, int pb) {
	array <int, 3> a;
	for (int j = 0 ; j < 3 ; ++ j) {
			int wa = pb - pa + lst[j];
			int wb = nxt[j] ? 0 : 3;
			a[j] = min(wa, wb);
	}
	return compress(a);
}

array <int, 3> decom(int x) {
	return {(x / (L * L)) % L, (x / L) % L, x % L};
}

int64_t eu_dist(int64_t a, int64_t b, int64_t x, int64_t y) {
	return (a - x) * (a - x) + (b - y) * (b - y);
}

int64_t min_dist(array <int, 3> A, int pa, array <int, 3> B, int pb) {
	int64_t D = INF;

	for (int i = 0 ; i < 3 ; ++ i) {
		if (A[i] == 3) continue;
		for (int j = 0 ; j < 3 ; ++ j) {
			if (B[j] == 0) continue;
			D = min(D, eu_dist(i, pa - A[i], j, pb));
		}
	}

	for (int j = 0 ; j < 3 ; ++ j)
	for (int k = j + 1 ; k < 3 ; ++ k) {
		if (B[j] && B[k]) {
			D = min(D, int64_t(k - j) * (k - j));
		}
	}

	return D == INF ? 0 : D;
}


void precompute() {
    for (int i = 0 ; i <= n ; ++ i)
    for (int state = 0 ; state < L * L * L ; ++ state) {
        array <int, 3> ps = decom(state);
        for (int nxt = i + 1 ; nxt <= n ; ++ nxt) {
                array <int, 3> t;
                for (int place = 1 ; place < 8 ; ++ place) {
                        precomp[i][state][nxt][place] = make_pair(-1, int64_t(-1));
                        int pcnt = 0;
                        for (int j = 0 ; j < 3 ; ++ j) {
                            if (place >> j & 1) t[j] = 1, pcnt += 1;
                            else t[j] = 0;
                        }
                        bool ok = true;
                        for (int x = 0 ; x < 3 ; ++ x) {
                            if (t[x] && s[x][nxt] == '#') {
                                ok = false;
                            }
                        }
                        if (!ok) continue;
                        int nxt_state = compress(ps, i, t, nxt);
                        int64_t D = min_dist(ps, i, t, nxt);
                        precomp[i][state][nxt][place] = make_pair(nxt_state, D);

            }
        }
    }
}
template <typename T>
inline void upd_max(T &a, T b) {
    if (a < b) a = b;
}

int main() {
	cin.tie(0)->sync_with_stdio(false);
	cin >> n >> k;


	for (int i = 0 ; i < 3 ; ++ i) {
		cin >> s[i];
		s[i] = '#' + s[i];
	}



	memset(dp, -1, sizeof(dp));

	dp[0][0][compress(3, 3, 3)] = 0;
	precompute();
	for (int i = 1 ; i < 8 ; ++ i) {
        cnt[i] = __builtin_popcount(i);
	}

	for (int i = 0 ; i < n ; ++ i) {
		for (int j = 0 ; j <= k ; ++ j) {
			for (int state = 0 ; state < L * L * L ; ++ state) {
				if (dp[i][j][state] == -1) continue;
				int64_t cur = dp[i][j][state];
				for (int nxt = i + 1 ; nxt <= n ; ++ nxt) {
					for (int place = 1 ; place < 8 ; ++ place) {
                        if (j + cnt[place] > k) continue;
                        auto [nxt_state, D] = precomp[i][state][nxt][place];
						if (nxt_state == -1) continue;
						upd_max(dp[nxt][j + cnt[place]][nxt_state], min(D, cur == 0 ? INF : cur));
					}
				}
			}
		}
	}
	int64_t ans = -1;

	for (int i = 0 ; i <= n ; ++ i) {
		for (int state = 0 ; state < L * L * L ; ++ state) {
			ans = max(ans, dp[i][k][state]);
			// if (ans == 16) cout << i << ' ' << k << ' ' << state << endl;
		}
	}


	if (ans == -1) {
		cout << ans << '\n';
	} else {
		cout.precision(10);
		cout << fixed;
		cout << sqrt(ans) << '\n';
	}


}