Madness
Contest: Codeforces Round 422 (Div. 2)
Difficulty rating: 2500
Tags: constructive algorithms, dfs and similar, trees

The second semester starts at the University of Pavlopolis. After vacation in Vičkopolis Noora needs to return to Pavlopolis and continue her study.

Sometimes (or quite often) there are teachers who do not like you. Incidentally Noora also has one such teacher. His name is Yury Dmitrievich and he teaches graph theory. Yury Dmitrievich doesn't like Noora, so he always gives the girl the most difficult tasks. So it happened this time.

The teacher gives Noora a tree with n vertices. Vertices are numbered with integers from 1 to n. The length of all the edges of this tree is 1. Noora chooses a set of simple paths that pairwise don't intersect in edges. However each vertex should belong to at least one of the selected path.

For each of the selected paths, the following is done:

1. We choose exactly one edge (u, v) that belongs to the path.
2. On the selected edge (u, v) there is a point at some selected distance x from the vertex u and at distance 1 - x from vertex v. But the distance x chosen by Noora arbitrarily, i. e. it can be different for different edges.
3. One of the vertices u or v is selected. The point will start moving to the selected vertex.

Let us explain how the point moves by example. Suppose that the path consists of two edges (v1, v2) and (v2, v3), the point initially stands on the edge (v1, v2) and begins its movement to the vertex v1. Then the point will reach v1, then "turn around", because the end of the path was reached, further it will move in another direction to vertex v2, then to vertex v3, then "turn around" again, then move to v2 and so on. The speed of the points is 1 edge per second. For example, for 0.5 second the point moves to the length of the half of an edge.

A stopwatch is placed at each vertex of the tree. The time that the stopwatches indicate at start time is 0 seconds. Then at the starting moment of time, all points simultaneously start moving from the selected positions to selected directions along the selected paths, and stopwatches are simultaneously started. When one of the points reaches the vertex v, the stopwatch at the vertex v is automatically reset, i.e. it starts counting the time from zero.

Denote by resv the maximal time that the stopwatch at the vertex v will show if the point movement continues infinitely. Noora is asked to select paths and points on them so that res1 is as minimal as possible. If there are several solutions to do this, it is necessary to minimize res2, then res3, res4, ..., resn.

Help Noora complete the teacher's task.

For the better understanding of the statement, see the explanation for the example.

Input format:
The first line contains single integer n (2 ≤ n ≤ 100) — number of vertices in the given tree.

Each of next n - 1 lines contains two integers u and v (1 ≤ u, v ≤ n, u ≠ v) — vertices connected by an edge.

Guaranteed that input defines a valid tree.

Output format:
In the first line print single integer paths — number of paths you want to choose.

In the next paths lines print path's descriptions:

1. Single integer len — number of edges in the current path.
2. len integers — indices of the edges in the path. The edges are numbered from 1 to n - 1 in order they are given in input.
3. Two integers u and v — means that you put point on the edge between vertices u and v (obviously the edge should belong to the path) and a point will start moving to the vertex v. Note that order of printing of the edge's ends is important. For example if you print "1 2" (without quotes), then point will start moving to vertex 2; but if you print "2 1" (without quotes), then point will start moving to vertex 1.
4. Single real number x (0 ≤ x ≤ 1) — distance between point and vertex u (the same vertex that you print first in the third paragraph).

Constraints:
Time limit: 2.0 s
Memory limit: 256.0 MB

Note:
Scoring:
Judge system will generate array res using the output data provided by the participant. Also system will generate array resOptimal by the jury answer. Your answer will be accepted if only for each i (1 ≤ i ≤ n) the following is satisfied: $$\frac{|res_i - resOptimal_i|}{max(1, resOptimal_i)} \leq 10^{-6}$$.

Consider an example.

In starting moment of time points are located as following:

The first path is highlighted in red, the second in blue, green circles represent chosen points, and brown numbers inside vertices — current time at stopwatch. Purple arrows represent direction in which points will move.

In 0.(3) seconds points will be located in following way (before stopwatch reset):

After stopwatch reset:

In 1.0 second after the start of moving:

In 1.(3) seconds after the start of moving (after stopwatch reset):

Finally, in 2 seconds after the start of moving points return to their initial positions.

This process will continue infinitely.

Example input:
3
1 2
2 3

Example output:
2
1 1 1 2 0.6666666666
1 2 2 3 0.6666666666

Editorial:
Firstly let's notice the fact that in the optimal answer each of the paths consists of exactly one edge.
Let's choose one particular vertex. Let's the degree of this vertex is deg. The most optimal answer for this vertex is $$\frac{2}{deg}$$, because one point make a full loop of the edge in 2 seconds. Vetrex with the degree deg has exactly deg adjacent edges. Consequentally deg distinct points will visit this vertex. Therefore in the optimal answer we should select all the starting positions and directions in such way that they visit the vertex each $$\frac{2}{deg}$$ seconds.
Let us show that we are able to select starting positions and directions so that the answer for every vertex is the optimal one.
Let's put points at the moment of time between 0 and 2 instead of putting somewhere on the edge. The moment of time between 0 and 1 will correspond to the coordinates from 0 to 1 in the direction from the vertex and the moment of time between 1 and 2 will correspond to the coordinates from 1 to 0 in the direction to the vertex.   Let's select a root among the tree vertices. Let's consider a case of the root. If there are deg adjacent edges we can put a point at 0.0 seconds on the first edge, at $$\frac{2}{deg}$$ seconds on the second edge, at $$2 \cdot \frac{2}{deg}$$ on the third edge, ..., at $$( \operatorname { d e g } - 1 ) \cdot { \frac { 2 } { \operatorname { d e g } } }$$ on the edge number deg.
Run the Depth First Search from the root (or Breadth First Search). Let's consider a case of another vertices. All these vertices will have a particular moment of time for the point in the upper edge. upEdgeMoment denotes this moment. So if the vertex degree is deg then the moments on the lower edges should be equal to $$upEdgeMoment + i \cdot \frac{2}{deg}$$ (here if the value exceeds 2, we calculate it modulo 2, i.e. 1.2 + 1.3 = 0.5), where i is the number of lower edge. The lower edges are numbered from 1 to deg - 1.
All in all, we are able to put points on every edge so that the answers for each vertex are the optimal one.
Total complexity is O(n).