#include <bits/stdc++.h>
namespace std {
template <typename _Key, typename _Hash = std::hash<_Key>>
using hash_set = std::unordered_set<_Key, _Hash>;
template <typename _Key, typename _Hash = std::hash<_Key>>
using hash_mset = std::unordered_multiset<_Key, _Hash>;
template <typename _Key, typename _Val, typename _Hash = std::hash<_Key>>
using hash_map = std::unordered_map<_Key, _Val, _Hash>;
template <typename _Key, typename _Hash = std::hash<_Key>>
using hash_mmap = std::unordered_multimap<_Key, _Hash>;
template <typename _Key, typename _Cmp = std::less<_Key>>
using mset = std::multiset<_Key, _Cmp>;
template <typename _Key, typename _Val, typename _Cmp = std::less<_Key>>
using mmap = std::multimap<_Key, _Val, _Cmp>;
template <typename _Key>
using rset = std::set<_Key, std::greater<_Key>>;
template <typename _Key>
using rmset = std::multiset<_Key, std::greater<_Key>>;
template <typename _Key, typename _Val>
using rmap = std::map<_Key, std::greater<_Key>>;
template <typename _Key, typename _Val>
using rmmap = std::multimap<_Key, _Val, std::greater<_Key>>;
static std::ostream& fdeb = cerr;
struct NullOstream {};
template <typename T>
NullOstream& operator<<(NullOstream& out, const T&) {
  return out;
}
NullOstream& operator<<(NullOstream& out, std::ostream& (*)(std::ostream&)) {
  return out;
}
static NullOstream deb;
static NullOstream debl;
template <int _Ind, typename... _Args>
struct __TuplePrinter {
  static void print(ostream& out, const tuple<_Args...>& t) {
    __TuplePrinter<_Ind - 1, _Args...>::print(out, t);
    out << ' ' << get<_Ind>(t);
  }
};
template <typename... _Args>
struct __TuplePrinter<0, _Args...> {
  static void print(ostream& out, const tuple<_Args...>& t) {
    out << '(' << get<0>(t);
  }
};
template <typename... _Args>
ostream& operator<<(ostream& out, const tuple<_Args...>& t) {
  __TuplePrinter<sizeof...(_Args) - 1, _Args...>::print(out, t);
  out << ')';
  return out;
}
template <typename _T1, typename _T2>
ostream& operator<<(ostream& out, const pair<_T1, _T2>& p) {
  return out << '(' << p.first << ' ' << p.second << ')';
}
using uchar = unsigned char;
using ushort = unsigned short;
using uint = unsigned int;
using lld = long long;
using ulld = unsigned long long;
static const int MOD = 1e9 + 7;
static const int INF = MOD;
static const lld HASHP = 37;
}  // namespace std
using namespace std;
int kerbosh(const std::vector<std::uint64_t>& g, std::uint64_t candidates,
            std::uint64_t banned = 0ULL, std::uint64_t cresult = 0ULL,
            int depth = 0) {
  if (candidates == 0) {
    return depth;
  }
  debl << std::hex << std::showbase << "depth: " << depth << " " << candidates
       << " " << banned << " " << cresult;
  int best_result = depth;
  ++depth;
  int abi = 0;
  for (std::uint64_t i = 0, ii = 1; i < g.size(); ++i, ii <<= 1) {
    if ((candidates | banned) & ii) {
      abi = i;
      break;
    }
  }
  std::uint64_t z = candidates & ~g[abi];
  for (std::uint64_t ci = 0, c = 1ULL; ci < g.size(); ++ci, c <<= 1) {
    if ((z & c) == 0) {
      continue;
    }
    best_result = std::max(
        best_result,
        kerbosh(g, candidates & g[ci], banned & g[ci], cresult | c, depth));
    candidates &= ~c;
    banned |= c;
  }
  return best_result;
}
int main() {
  int N, K;
  cin >> N >> K;
  vector<std::uint64_t> g(N);
  for (auto& v : g) {
    v = 0;
    for (int i = 0; i < N; ++i) {
      long long vv;
      std::cin >> vv;
      v |= (vv << i);
    }
  }
  std::uint64_t max_click = kerbosh(g, (1ULL << g.size()) - 1);
  debl << max_click;
  std::cout << std::fixed << std::setprecision(8)
            << (0.5 * K * K * (max_click - 1) / max_click) << std::endl;
  return 0;
}
