Problem: Bearland has n cities, numbered 1 through n. There are m bidirectional roads. The i-th road connects two distinct cities ai and bi. No two roads connect the same pair of cities. It's possible to get from any city to any other city (using one or more roads).

The distance between cities a and b is defined as the minimum number of roads used to travel between a and b.

Limak is a grizzly bear. He is a criminal and your task is to catch him, or at least to try to catch him. You have only two days (today and tomorrow) and after that Limak is going to hide forever.

Your main weapon is BCD (Bear Criminal Detector). Where you are in some city, you can use BCD and it tells you the distance between you and a city where Limak currently is. Unfortunately, BCD can be used only once a day.

You don't know much about Limak's current location. You assume that he is in one of n cities, chosen uniformly at random (each city with probability <image>). You decided for the following plan:

  1. Choose one city and use BCD there. 
    * After using BCD you can try to catch Limak (but maybe it isn't a good idea). In this case you choose one city and check it. You win if Limak is there. Otherwise, Limak becomes more careful and you will never catch him (you loose). 
  2. Wait 24 hours to use BCD again. You know that Limak will change his location during that time. In detail, he will choose uniformly at random one of roads from his initial city, and he will use the chosen road, going to some other city. 
  3. Tomorrow, you will again choose one city and use BCD there. 
  4. Finally, you will try to catch Limak. You will choose one city and check it. You will win if Limak is there, and loose otherwise. 



Each time when you choose one of cities, you can choose any of n cities. Let's say it isn't a problem for you to quickly get somewhere.

What is the probability of finding Limak, if you behave optimally?

Input

The first line of the input contains two integers n and m (2 ≤ n ≤ 400, <image>) — the number of cities and the number of roads, respectively.

Then, m lines follow. The i-th of them contains two integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) — cities connected by the i-th road.

No two roads connect the same pair of cities. It's possible to get from any city to any other city.

Output

Print one real number — the probability of finding Limak, if you behave optimally. Your answer will be considered correct if its absolute error does not exceed 10 - 6.

Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if |a - b| ≤ 10 - 6.

Examples

Input

3 3
1 2
1 3
2 3


Output

0.833333333333


Input

5 4
1 2
3 1
5 1
1 4


Output

1.000000000000


Input

4 4
1 2
1 3
2 3
1 4


Output

0.916666666667


Input

5 5
1 2
2 3
3 4
4 5
1 5


Output

0.900000000000

Note

In the first sample test, there are three cities and there is a road between every pair of cities. Let's analyze one of optimal scenarios.

  1. Use BCD in city 1. 
    * With probability <image> Limak is in this city and BCD tells you that the distance is 0. You should try to catch him now and you win for sure. 
    * With probability <image> the distance is 1 because Limak is in city 2 or city 3. In this case you should wait for the second day. 
  2. You wait and Limak moves to some other city. 
    * There is probability <image> that Limak was in city 2 and then went to city 3. 
    * <image> that he went from 2 to 1. 
    * <image> that he went from 3 to 2. 
    * <image> that he went from 3 to 1. 
  3. Use BCD again in city 1 (though it's allowed to use it in some other city). 
    * If the distance is 0 then you're sure Limak is in this city (you win). 
    * If the distance is 1 then Limak is in city 2 or city 3. Then you should guess that he is in city 2 (guessing city 3 would be fine too). 



You loose only if Limak was in city 2 first and then he moved to city 3. The probability of loosing is <image>. The answer is <image>.

Solution (in JAVA):

Solution:
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        static final int INF = Integer.MAX_VALUE / 2;

        void floydWarshall(int[][] d) {
            int n = d.length;
            for (int k = 0; k < n; k++) {
                for (int i = 0; i < n; i++) {
                    for (int j = 0; j < n; j++) {
                        if (d[i][j] > d[i][k] + d[k][j]) {
                            d[i][j] = d[i][k] + d[k][j];
                        }
                    }
                }
            }
        }

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt(), m = in.nextInt();
            int[][] d = new int[n][n];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    d[i][j] = (i == j) ? 0 : INF;
                }
            }
            List<Integer>[] graph = Stream.generate(ArrayList::new).limit(n).toArray(List[]::new);
            for (int i = 0; i < m; i++) {
                int u = in.nextInt(), v = in.nextInt();
                u--;
                v--;
                d[u][v] = d[v][u] = 1;
                graph[u].add(v);
                graph[v].add(u);
            }

            floydWarshall(d);

            double ans = 0;
            double[] max_prob = new double[n];
            int[] there = new int[n];
            int cntr = 0;

            for (int i = 0; i < n; i++) {
                List<Integer>[] distances = Stream.generate(ArrayList::new).limit(n).toArray(List[]::new);
                for (int j = 0; j < n; j++) distances[d[i][j]].add(j);
                double ans2 = 0;
                for (int D = 0; D < n; D++) {
                    if (distances[D].isEmpty()) continue;
                    double prob = distances[D].size() / (double) n;
                    double[] curr_prob = new double[n];
                    boolean[] present = new boolean[n];
                    for (int node : distances[D]) {
                        double add = 1. / graph[node].size();
                        for (int node2 : graph[node]) {
                            curr_prob[node2] += add / n;
                            present[node2] = true;
                        }
                    }

                    List<Integer> valid = new ArrayList<>();

                    for (int j = 0; j < n; j++) if (present[j]) valid.add(j);
                    double mx = 0;
                    for (int select = 0; select < n; select++) {
                        cntr++;
                        double sm = 0;
                        for (int node : valid) {
                            if (there[d[select][node]] != cntr) {
                                there[d[select][node]] = cntr;
                                max_prob[d[select][node]] = 0;
                            }
                            sm += Math.max(0., -max_prob[d[select][node]] + curr_prob[node]);
                            max_prob[d[select][node]] = Math.max(max_prob[d[select][node]], curr_prob[node]);
                        }
                        mx = Math.max(mx, sm);
                    }
                    ans2 += Math.max(mx, 1. / n);
                }
                ans = Math.max(ans, ans2);
            }
            out.print(ans);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        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 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 boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void close() {
            writer.close();
        }

    }
}