You are given a tree (an undirected connected graph without cycles) and an integer s.

Vanya wants to put weights on all edges of the tree so that all weights are non-negative real numbers and their sum is s. At the same time, he wants to make the diameter of the tree as small as possible.

Let's define the diameter of a weighed tree as the maximum sum of the weights of the edges lying on the path between two some vertices of the tree. In other words, the diameter of a weighed tree is the length of the longest simple path in the tree, where length of a path is equal to the sum of weights over all edges in the path.

Find the minimum possible diameter that Vanya can get.

Input

The first line contains two integer numbers n and s (2 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of vertices in the tree and the sum of edge weights.

Each of the following n−1 lines contains two space-separated integer numbers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the indexes of vertices connected by an edge. The edges are undirected.

It is guaranteed that the given edges form a tree.

Output

Print the minimum diameter of the tree that Vanya can get by placing some non-negative real weights on its edges with the sum equal to s.

Your answer will be considered correct if its absolute or relative error does not exceed 10^{-6}.

Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac {|a-b|} {max(1, b)} ≤ 10^{-6}.

Examples

Input


4 3
1 2
1 3
1 4


Output


2.000000000000000000

Input


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


Output


0.500000000000000000

Input


5 5
1 2
2 3
3 4
3 5


Output


3.333333333333333333

Note

In the first example it is necessary to put weights like this:

<image>

It is easy to see that the diameter of this tree is 2. It can be proved that it is the minimum possible diameter.

In the second example it is necessary to put weights like this:

<image>
import java.util.*;
import java.io.*;

public class Dijkstra {
	static class Point{
		int x;int y;int r;
		public Point(int x,int y,int radius) {
			this.x=x;this.y=y;r=radius;
		}
	}
	static class Node {
		int index;
		double value;
		public Node(int index,double value) {
			this.index=index;this.value=value;
		}
	}
	static class Edge{
		int to;double cost;
		public Edge(int to,double cost) {
			this.to=to;this.cost=cost;
		}
	}
	public static double[] dijkstra(ArrayList<ArrayList<Edge>> bunker,int src,int n) {
		boolean[] vis = new boolean[n+1];
		double[] dist = new double[n+1];
		for (int i = 0;i<=n;i++) {
			dist[i]=Double.MAX_VALUE;
			
		}
		dist[src]=0;vis[src]=true;
		PriorityQueue<Node> lol = new PriorityQueue<>(new RRR());
		lol.add(new Node(src,0));
		while (!lol.isEmpty()) {
			Node aa = lol.poll();
			
			vis[aa.index]=true;
			if (dist[aa.index]<aa.value) continue;
			for (Edge e : bunker.get(aa.index)) {
				if (!vis[e.to]) {
					double dista = aa.value+e.cost;
					if (dista<dist[e.to]) {
						dist[e.to]=dista;
						lol.add(new Node(e.to,dista));
//						System.out.println(aa.index+" "+e.to+" "+dista+" "+e.cost);
					}
				}
			}
		}
		return dist;
		
	}

	public static void main(String[] args) throws IOException {
		Reader.init(System.in);
		int n = Reader.nextInt();int k = Reader.nextInt();int m = n-1;int[] arr = new int[n+1];
		for (int i = 0;i<m;i++) {
			int x = Reader.nextInt();int y = Reader.nextInt();
			arr[x]++;
			arr[y]++;
			
		}int ck = 0;
		for (int j = 1;j<=n;j++) {
			if (arr[j]==1) ck++;
		}
		System.out.println(2*k/(ck*1.0));
	}
	
	
	static class RRR implements Comparator<Node>{
		@Override
		public int compare(Node o1, Node o2) {
			// TODO Auto-generated method stub
			return Double.compare(o1.value, o2.value);
		}
	}

}
class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;
    static void init(InputStream input) {
        reader = new BufferedReader(
                     new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                   reader.readLine() );
        }
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt( next() );
    }
	
    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
    static long nextLong() throws IOException {
        return Long.parseLong( next() );
    }
}
