Problem: Igor the analyst has adopted n little bunnies. As we all know, bunnies love carrots. Thus, Igor has bought a carrot to be shared between his bunnies. Igor wants to treat all the bunnies equally, and thus he wants to cut the carrot into n pieces of equal area. 

Formally, the carrot can be viewed as an isosceles triangle with base length equal to 1 and height equal to h. Igor wants to make n - 1 cuts parallel to the base to cut the carrot into n pieces. He wants to make sure that all n pieces have the same area. Can you help Igor determine where to cut the carrot so that each piece have equal area?

<image> Illustration to the first example.

Input

The first and only line of input contains two space-separated integers, n and h (2 ≤ n ≤ 1000, 1 ≤ h ≤ 105).

Output

The output should contain n - 1 real numbers x1, x2, ..., xn - 1. The number xi denotes that the i-th cut must be made xi units away from the apex of the carrot. In addition, 0 < x1 < x2 < ... < xn - 1 < h must hold. 

Your output will be considered correct if absolute or relative error of every number in your output doesn't exceed 10 - 6.

Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.

Examples

Input

3 2


Output

1.154700538379 1.632993161855


Input

2 100000


Output

70710.678118654752

Note

Definition of isosceles triangle: <https://en.wikipedia.org/wiki/Isosceles_triangle>.

Solution (in JAVA):

Solution:
import java.util.*;
import java.util.stream.*;

public class CuttingCarrot {
  private static final double base = 1.0;
  private static final double threshold = 1e-8;
  
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int n = in.nextInt();
    int h = in.nextInt();
    System.out.println(solve((double) n, (double) h));
  }
  
  /*
   * sizePerPiece = total size / n
   * areaUsed = 0
   * for n - 1, binary search:
   *   height of mid cut (from top) = midHeight = (h - prevCut) / 2 + prevCut
   *                     = (h + prevCut) / 2
   *   totalArea = smallBase * midHeight / 2
   *     smallBase / largeBase = midHeight / h
   *     smallBase = 1 * midHeight / h
   *   if totalArea ~ sizePerPiece * pieceNumber, return midHeight
   *   if <, if >
   */
  public static String solve(double n, double h) {
    double sizePerPiece = base * h / 2 / n;
    double prevCut = 0.0;
    
    for (int i = 1; i < n; i++) {
      double cutLocation = binarySearch(h, h, prevCut, sizePerPiece * (double) i);
      System.out.print(cutLocation + " ");
      prevCut = cutLocation;
    }
    
    return "";
  }
  
  private static double binarySearch(double h, double bottomLimit, double topLimit, double neededArea) {
    double midHeight = (bottomLimit + topLimit) / 2;
    double totalArea = base * midHeight * midHeight / 2 / h;
    
    /*System.out.println("bottomLimit: " + bottomLimit + ", topLimit: " + topLimit
                         + ", midHeight: " + midHeight + ", totalArea: " + totalArea
                         + ", neededArea: " + neededArea);*/
    
    if (Math.abs(totalArea - neededArea) <= threshold) {
      return midHeight;
    }
    
    if (totalArea < neededArea) {
      return binarySearch(h, bottomLimit, midHeight + threshold, neededArea);
    }
    return binarySearch(h, midHeight - threshold, topLimit, neededArea);
  }
}