#include <cmath>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

double solve(int N, int K, const vector<string>& S) {
	vector<int> cand;
	for (int i = 0; i <= N; i++) {
		for (int j = 0; j <= 2; j++) {
			cand.push_back(i * i + j * j);
		}
	}
	sort(cand.begin(), cand.end());
	cand.erase(unique(cand.begin(), cand.end()), cand.end());
	vector<vector<int> > nxt(3, vector<int>(N + 1, N));
	for (int i = 0; i < 3; i++) {
		for (int j = N - 1; j >= 0; j--) {
			nxt[i][j] = (S[i][j] == '.' ? j : nxt[i][j + 1]);
		}
	}
	int l = -1, r = int(cand.size());
	while (r - l > 1) {
		int m = (l + r) / 2;
		int b = cand[m];
		vector<int> dp((N + 1) * (N + 1) * (N + 1), -1);
		auto encode = [&](int x, int y, int z) -> int {
			return (x + 1) * (N + 1) * (N + 1) + (y + 1) * (N + 1) + (z + 1);
		};
		int q0 = 0, q1 = 0, q2 = 0;
		while (q0 * q0 < b) q0++;
		while (q1 * q1 + 1 < b) q1++;
		while (q2 * q2 + 4 < b) q2++;
		auto dfs = [&](auto& self, int x, int y, int z) -> int {
			int h = encode(x, y, z);
			if (dp[h] != -1) {
				return dp[h];
			}
			int p = max({x, y, z});
			int xl = p + 1;
			int yl = (y == p || z == p ? p + 1 : p);
			int zl = (z == p ? p + 1 : p);
			if (x != -1) {
				xl = max(xl, x + q0);
				yl = max(yl, x + q1);
				zl = max(zl, x + q2);
			}
			if (y != -1) {
				xl = max(xl, y + q1);
				yl = max(yl, y + q0);
				zl = max(zl, y + q1);
			}
			if (z != -1) {
				xl = max(xl, z + q2);
				yl = max(yl, z + q1);
				zl = max(zl, z + q0);
			}
			xl = min(xl, N);
			yl = min(yl, N);
			zl = min(zl, N);
			xl = nxt[0][xl];
			yl = nxt[1][yl];
			zl = nxt[2][zl];
			int res = 0;
			if (xl != N) {
				int subres = self(self, xl, y, z);
				res = max(res, subres + 1);
			}
			if (yl != N) {
				int subres = self(self, x, yl, z);
				res = max(res, subres + 1);
			}
			if (zl != N) {
				int subres = self(self, x, y, zl);
				res = max(res, subres + 1);
			}
			dp[h] = res;
			return res;
		};
		int res = dfs(dfs, -1, -1, -1);
		if (res >= K) {
			l = m;
		} else {
			r = m;
		}
	}
	return (l != -1 ? sqrt(cand[l]) : -1);
}

int main() {
	int N, K;
	cin >> N >> K;
	vector<string> S(3);
	for (int i = 0; i < 3; i++) {
		cin >> S[i];
	}
	double ans = solve(N, K, S);
	if (ans != -1) {
		cout.precision(15);
		cout << ans << endl;
	} else {
		cout << -1 << endl;
	}
	return 0;
}