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.PrintStream;
import java.util.Collection;
import java.io.IOException;
import java.util.Deque;
import java.util.ArrayList;
import java.io.UncheckedIOException;
import java.math.BigDecimal;
import java.util.List;
import java.io.Closeable;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.ArrayDeque;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) throws Exception {
        Thread thread = new Thread(null, new TaskAdapter(), "", 1 << 29);
        thread.start();
        thread.join();
    }

    static class TaskAdapter implements Runnable {
        @Override
        public void run() {
            InputStream inputStream = System.in;
            OutputStream outputStream = System.out;
            FastInput in = new FastInput(inputStream);
            FastOutput out = new FastOutput(outputStream);
            DBearAndChase solver = new DBearAndChase();
            solver.solve(1, in, out);
            out.close();
        }
    }

    static class DBearAndChase {
        Debug debug = new Debug(true);

        public void solve(int testNumber, FastInput in, FastOutput out) {
            int n = in.readInt();
            int m = in.readInt();

            Node[] nodes = new Node[n];
            for (int i = 0; i < n; i++) {
                nodes[i] = new Node();
                nodes[i].size = new int[n];
                nodes[i].id = i;
                nodes[i].probMax = new double[n];
            }
            for (int i = 0; i < m; i++) {
                Node a = nodes[in.readInt() - 1];
                Node b = nodes[in.readInt() - 1];
                a.adj.add(b);
                b.adj.add(a);
            }

            int inf = (int) 1e8;
            Deque<Node> dq = new ArrayDeque<>(n);
            int[][] dists = new int[n][n];
            for (int i = 0; i < n; i++) {
                Node first = nodes[i];
                dq.clear();
                for (Node node : nodes) {
                    node.dist = inf;
                }
                first.dist = 0;
                dq.addLast(first);
                while (!dq.isEmpty()) {
                    Node head = dq.removeFirst();
                    dists[i][head.id] = head.dist;
                    first.size[head.dist]++;
                    for (Node node : head.adj) {
                        if (node.dist > head.dist + 1) {
                            node.dist = head.dist + 1;
                            dq.addLast(node);
                        }
                    }
                }
            }

            double maxProb = 0;
            for (int i = 0; i < n; i++) {
                Node first = nodes[i];

                double firstProb = 0;
                for (int j = 0; j < n && first.size[j] > 0; j++) {
                    double levelProb = first.size[j] / (double) n;
                    double directProb = 1d / first.size[j];

                    for (Node node : nodes) {
                        node.prob = 0;
                        node.inq = false;
                    }

                    dq.clear();
                    for (int k = 0; k < n; k++) {
                        if (dists[i][k] != j) {
                            continue;
                        }
                        Node possiblePos = nodes[k];
                        double distribute = directProb / possiblePos.adj.size();
                        for (Node node : possiblePos.adj) {
                            node.prob += distribute;
                            if (!node.inq) {
                                node.inq = true;
                                dq.addLast(node);
                            }
                        }
                    }

                    for (Node node : dq) {
                        for (int k = 0; k < n; k++) {
                            int d = dists[node.id][k];
                            nodes[k].probMax[d] = Math.max(nodes[k].probMax[d], node.prob);
                        }
                    }

                    //try third
                    double bestChoice = 0;
                    for (Node second : nodes) {
                        double secondSum = 0;
                        for (Node node : dq) {
                            int d = dists[node.id][second.id];
                            secondSum += second.probMax[d];
                            second.probMax[d] = 0;
                        }
                        bestChoice = Math.max(bestChoice, secondSum);
                    }

                    double bestProb = Math.max(bestChoice, directProb);
                    firstProb += bestProb * levelProb;
                }

                debug.debug("i", i);
                debug.debug("firstProb", firstProb);
                maxProb = Math.max(maxProb, firstProb);
            }

            out.println(maxProb);
        }

    }

    static class Debug {
        private boolean offline;
        private PrintStream out = System.err;

        public Debug(boolean enable) {
            offline = enable && System.getSecurityManager() == null;
        }

        public Debug debug(String name, int x) {
            if (offline) {
                debug(name, "" + x);
            }
            return this;
        }

        public Debug debug(String name, double x) {
            if (offline) {
                debug(name, "" + x);
            }
            return this;
        }

        public Debug debug(String name, String x) {
            if (offline) {
                out.printf("%s=%s", name, x);
                out.println();
            }
            return this;
        }

    }

    static class FastInput {
        private final InputStream is;
        private byte[] buf = new byte[1 << 13];
        private int bufLen;
        private int bufOffset;
        private int next;

        public FastInput(InputStream is) {
            this.is = is;
        }

        private int read() {
            while (bufLen == bufOffset) {
                bufOffset = 0;
                try {
                    bufLen = is.read(buf);
                } catch (IOException e) {
                    bufLen = -1;
                }
                if (bufLen == -1) {
                    return -1;
                }
            }
            return buf[bufOffset++];
        }

        public void skipBlank() {
            while (next >= 0 && next <= 32) {
                next = read();
            }
        }

        public int readInt() {
            int sign = 1;

            skipBlank();
            if (next == '+' || next == '-') {
                sign = next == '+' ? 1 : -1;
                next = read();
            }

            int val = 0;
            if (sign == 1) {
                while (next >= '0' && next <= '9') {
                    val = val * 10 + next - '0';
                    next = read();
                }
            } else {
                while (next >= '0' && next <= '9') {
                    val = val * 10 - next + '0';
                    next = read();
                }
            }

            return val;
        }

    }

    static class Node {
        int[] size;
        List<Node> adj = new ArrayList<>();
        int dist;
        double prob;
        int id;
        boolean inq;
        double[] probMax;

        public String toString() {
            return "" + (id + 1);
        }

    }

    static class FastOutput implements AutoCloseable, Closeable, Appendable {
        private StringBuilder cache = new StringBuilder(10 << 20);
        private final Writer os;

        public FastOutput append(CharSequence csq) {
            cache.append(csq);
            return this;
        }

        public FastOutput append(CharSequence csq, int start, int end) {
            cache.append(csq, start, end);
            return this;
        }

        public FastOutput(Writer os) {
            this.os = os;
        }

        public FastOutput(OutputStream os) {
            this(new OutputStreamWriter(os));
        }

        public FastOutput append(char c) {
            cache.append(c);
            return this;
        }

        public FastOutput append(double c) {
            cache.append(new BigDecimal(c).toPlainString());
            return this;
        }

        public FastOutput println(double c) {
            return append(c).println();
        }

        public FastOutput println() {
            cache.append(System.lineSeparator());
            return this;
        }

        public FastOutput flush() {
            try {
                os.append(cache);
                os.flush();
                cache.setLength(0);
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
            return this;
        }

        public void close() {
            flush();
            try {
                os.close();
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }

        public String toString() {
            return cache.toString();
        }

    }
}