source_code: import java.io.*;
  import java.util.*;
  import java.math.*;
  import java.lang.*;
   
  import static java.lang.Math.*;
   
  public class Main implements Runnable
  {
  	static class InputReader
  	{
  		private InputStream stream;
  		private byte[] buf = new byte[1024];
  		private int curChar;
  		private int numChars;
  		private SpaceCharFilter filter;
  		private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  
  		public InputReader(InputStream stream)
  		{
  			this.stream = stream;
  		}
  		
  		public int read()
  		{
  			if (numChars==-1) 
  				throw new InputMismatchException();
  			
  			if (curChar >= numChars)
  			{
  				curChar = 0;
  				try 
  				{
  					numChars = stream.read(buf);
  				}
  				catch (IOException e)
  				{
  					throw new InputMismatchException();
  				}
  				
  				if(numChars <= 0)				
  					return -1;
  			}
  			return buf[curChar++];
  		}
  	 
  		public String nextLine()
  		{
  			String str = "";
              try
              {
                  str = br.readLine();
              }
              catch (IOException e)
              {
                  e.printStackTrace();
              }
              return str;
  		}
  		public int nextInt()
  		{
  			int c = read();
  			
  			while(isSpaceChar(c)) 
  				c = read();
  			
  			int sgn = 1;
  			
  			if (c == '-') 
  			{
  				sgn = -1;
  				c = read();
  			}
  			
  			int res = 0;
  			do 
  			{
  				if(c<'0'||c>'9') 
  					throw new InputMismatchException();
  				res *= 10;
  				res += c - '0';
  				c = read();
  			}
  			while (!isSpaceChar(c)); 
  			
  			return res * sgn;
  		}
  		
  		public long nextLong() 
  		{
  			int c = read();
  			while (isSpaceChar(c))
  				c = read();
  			int sgn = 1;
  			if (c == '-') 
  			{
  				sgn = -1;
  				c = read();
  			}
  			long res = 0;
  			
  			do 
  			{
  				if (c < '0' || c > '9')
  					throw new InputMismatchException();
  				res *= 10;
  				res += c - '0';
  				c = read();
  			}
  			while (!isSpaceChar(c));
  				return res * sgn;
  		}
  		
  		public double nextDouble() 
  		{
  			int c = read();
  			while (isSpaceChar(c))
  				c = read();
  			int sgn = 1;
  			if (c == '-') 
  			{
  				sgn = -1;
  				c = read();
  			}
  			double res = 0;
  			while (!isSpaceChar(c) && c != '.') 
  			{
  				if (c == 'e' || c == 'E')
  					return res * Math.pow(10, nextInt());
  				if (c < '0' || c > '9')
  					throw new InputMismatchException();
  				res *= 10;
  				res += c - '0';
  				c = read();
  			}
  			if (c == '.') 
  			{
  				c = read();
  				double m = 1;
  				while (!isSpaceChar(c)) 
  				{
  					if (c == 'e' || c == 'E')
  						return res * Math.pow(10, nextInt());
  					if (c < '0' || c > '9')
  						throw new InputMismatchException();
  					m /= 10;
  					res += (c - '0') * m;
  					c = read();
  				}
  			}
  			return res * sgn;
  		}
  		
  		public String readString() 
  		{
  			int c = read();
  			while (isSpaceChar(c))
  				c = read();
  			StringBuilder res = new StringBuilder();
  			do 
  			{
  				res.appendCodePoint(c);
  				c = read();
  			} 
  			while (!isSpaceChar(c));
  			
  			return res.toString();
  		}
  	 
  		public boolean isSpaceChar(int c) 
  		{
  			if (filter != null)
  				return filter.isSpaceChar(c);
  			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
  		}
  	 
  		public String next() 
  		{
  			return readString();
  		}
  		
  		public interface SpaceCharFilter 
  		{
  			public boolean isSpaceChar(int ch);
  		}
  	}
   	
  	public static void main(String args[]) throws Exception
  	{
  		new Thread(null, new Main(),"Main",1<<26).start();
  	}	
      int findLSB(long n)
      {
          long value=-n&n;
          return map.get(value);
      }
  	void findMaxClique(long mask,int size)
      {
          if(mask==0)
          {
              if(size>maxClique)
                  maxClique=size;
              return;    
          }
          while(mask>0)
          {
              if(Long.bitCount(mask)+size<=maxClique)
                  return;
              int lsb=findLSB(mask);
              mask=mask^((long)1<<lsb);
              findMaxClique(mask&edges[lsb],size+1);
          }
      }
      long edges[];
      HashMap<Long,Integer> map=new HashMap<>();
      int maxClique;
  	public void run()
  	{
  		InputReader sc= new InputReader(System.in);
  		PrintWriter w= new PrintWriter(System.out);
          long value=1;
          for(int i=0;i<45;i++)
          {
              map.put(value,i);
              value*=2;
          }
          int n=sc.nextInt();
  	    int k=sc.nextInt();
          edges=new long[n];
          for(int i=0;i<n;i++)
          {
              for(int j=0;j<n;j++)
              {
                  long connect=sc.nextLong();
                  if(j>i&&connect==1)
                      edges[i]|=(connect<<j);
              }
          }
          findMaxClique(((long)1<<n)-1,0);
          //w.print(maxClique);
          double size=(double)maxClique;
          double perCastle=(double)k/size;
          double ans=perCastle*perCastle*(size*(size-1))/2;
          w.print(ans);
  		w.close();		
  	}
  }