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 javax.print.attribute.standard.MediaPrintableArea;
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.*;

/**
 * Created by Firеfly on 1/1/2017.
 */
public class Task {
    public static void main(String[] args) throws IOException {
        Emaxx emaxx = new Emaxx();
    }
}


class Emaxx {
    FScanner fs;
    PrintWriter pw;
    int n, m;
    ArrayList<Integer>[] graph;
    int[] comp;
    LinkedList<Pair> qoue;
    Emaxx() throws IOException {
        fs = new FScanner(new InputStreamReader(System.in));
        // pw = new PrintWriter(new FileWriter("arithnumbers.out"));
        //  fs = new FScanner(new FileReader("C:\\Users\\Firеfly\\Desktop\\New Text Document.txt"));
        //     fs = new FScanner(new FileReader("input.txt"));;
        //       pw = new PrintWriter("output.txt");
        PrintWriter pw = new PrintWriter(System.out);
        int n = fs.nextInt();
        int h = fs.nextInt();
        double s = h*1.0/2/n;
        double ss = h*1.0/2;
        double k1 = Math.sqrt(2*s/h);
        double curS = 0;
        double h1 = k1*h;
        double H = k1*h;
        for (int i = 0; i<n-1; i++) {
            pw.print(H + " ");
            curS = s*(i+2);
            double k2 = Math.sqrt(curS/ss);
            H = k2*h;
        }
        pw.close();
    }

    double round(double number, int scale) {
        int pow = 10;
        for (int i = 1; i < scale; i++)
            pow *= 10;
        double tmp = number * pow;
        return (double) (int) ((tmp - (int) tmp) >= 0.5 ? tmp + 1 : tmp) / pow;
    }

    int gcd(int a, int b) {
        if (b == 0)
            return a;
        else return gcd(b, a%b);
    }
}
class Tree1 {
    int[] t;
    int n;
    Tree1(ArrayList<Pair> a) {
        n = a.size();
        t = new int[n*4];
        build(a, 1, 0, n-1);
    }
    void build (ArrayList<Pair> a, int v, int tl, int tr) {
        if (tl == tr)
            t[v] = a.get(tl).x;
        else {
            int tm = (tl + tr) / 2;
            build (a, v*2, tl, tm);
            build (a, v*2+1, tm+1, tr);
            t[v] = Math.max(t[v*2], t[v*2+1]);
        }
    }
    int sum (int v, int tl, int tr, int l, int r) {
        if (l > r)
            return 0;
        if (l == tl && r == tr)
            return t[v];
        int tm = (tl + tr) / 2;
        return Math.max(sum (v*2, tl, tm, l, Math.min(r,tm))
                , sum (v*2+1, tm+1, tr, Math.max(l,tm+1), r));
    }
    void update (int v, int tl, int tr, int pos, int new_val) {
        if (tl == tr)
            t[v] = new_val;
        else {
            int tm = (tl + tr) / 2;
            if (pos <= tm)
                update (v*2, tl, tm, pos, new_val);
            else
                update (v*2+1, tm+1, tr, pos, new_val);
            t[v] = Math.max(t[v*2], t[v*2+1]);
        }
    }

}
class FScanner {
    BufferedReader br;
    StringTokenizer st;
    FScanner(InputStreamReader isr) {
        br = new BufferedReader(isr);
    }

    FScanner(FileReader fr) {
        br = new BufferedReader(fr);
    }

    String nextToken() throws IOException{
        while (st == null || !st.hasMoreTokens()) {
            String s = br.readLine();
            if (s == null)
                return null;
            st = new StringTokenizer(s);
        }
        return st.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    String nextLine() throws IOException {
        return br.readLine();
    }

    char nextChar() throws IOException {
        return (char) br.read();
    }
}

class Pair implements Comparable<Pair>{
    int x, y;
    boolean used;
    Pair(int x1, int y1) {x = x1; y = y1;}

    @Override
    public int compareTo(Pair o) {
        return Integer.compare(y, o.y);
    }
}