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.io.*;
import java.math.*;
import java.util.*;
import javax.print.attribute.SetOfIntegerSyntax;

 public class Main {
	private static InputStream stream;
	private static byte[] buf = new byte[1024];
	private static int curChar;
	private static int numChars;
	private static SpaceCharFilter filter;
	private static PrintWriter pw;
	private static long count = 0,mod=1000000007;
	private static TreeSet<Integer>ts[]=new TreeSet[200000];

	public static void main(String args[]) throws Exception {
		InputReader(System.in);
		pw = new PrintWriter(System.out);
		//ans();
		soln();
		pw.close();
	}
	//----------------------------------------My Code------------------------------------------------//

	private static void soln() {
	    int n=nextInt();
	    int h=nextInt();
	    for(int i=1;i<n;i++)
	    
	    {
	        double ans=Math.sqrt((double)i/(double)n);
	        ans*=(double)h;
	        System.out.printf("%.12f ",ans);
	    }
            
             
}
	private static void primeFactors(int n,int ind,int[] ans)
	{
		int flag=1;
	    // Print the number of 2s that divide n
	    while (n%2 == 0)
	    {flag=0;
	      n = n/2;
	    }
	    if(flag==0) {
	    	
	    	if(ts[2]==null){
	    	ts[2]=new TreeSet<Integer>();
	    	}
	    	else{
	    		if(ts[2].floor(ind)!=null){
	    			//pw.println(ind+"--");
	    			int d1=ts[2].floor(ind);

	    			//pw.println(d1+" d1");
	    			if(Math.abs(ind-ans[ind])> Math.abs(ind-d1))
		    		ans[ind]=d1;
	    			
		    		if(Math.abs(ans[d1]-d1)>Math.abs(ind-d1)){
		    			ans[d1]=ind;
		    		}
	    		}
	    	}
	    	ts[2].add(ind);
	    }
	 
	    // n must be odd at this point.  So we can skip one element (Note i = i +2)
	    for (int i = 3; i <= Math.sqrt(n); i = i+2)
	    {
	    	flag=1;
	        // While i divides n, print i and divide n
	        while (n%i == 0)
	        {
	          flag=0;  
	            n = n/i;
	        }
	        if(flag==0){
	        	if(ts[i]==null){
	    	    	ts[i]=new TreeSet<Integer>();
	    	    	}
	    	    	else{
	    	    		if(ts[i].floor(ind)!=null){
	    	    			int d1=ts[i].floor(ind);
	    	    			if(Math.abs(ind-ans[ind])> Math.abs(ind-d1))
	    			    		ans[ind]=d1;
	    		  
	    		    		if(Math.abs(ans[d1]-d1)>Math.abs(ind-d1)){
	    		    			ans[d1]=ind;
	    		    		}
	    	    		}
	    	    	}
	    	    	ts[i].add(ind);

	        }
	        
	    }
	 
	    // This condition is to handle the case whien n is a prime number
	    // greater than 2
	    if (n > 2)
	    {
	    	if(ts[n]==null){
    	    	ts[n]=new TreeSet<Integer>();
    	    	}
    	    	else{
    	    		if(ts[n].floor(ind)!=null){
    	    			int d1=ts[n].floor(ind);
    	    			if(Math.abs(ind-ans[ind])> Math.abs(ind-d1))
    			    		ans[ind]=d1;
    		    		
    		    		if(Math.abs(ans[d1]-d1)>Math.abs(ind-d1)){
    		    			ans[d1]=ind;
    		    		}
    	    		}
    	    	}
    	    	ts[n].add(ind);

        }
	}
	
	//----------------------------------------THE END----------------------------------------------------------//        	

	static class Pair implements Comparable<Pair>{

		int idx,val;
		Pair(int idx,int val){
			this.idx=idx;
			this.val=val;
		}
		@Override
		public int compareTo(Pair o) {
			// TODO Auto-generated method stub
		//	Sort in increasing order

		
			if(o.idx<idx){
				return 1;
			}
			if(o.idx==idx && o.val<val){
				return 1;
			}else{
				return -1;
			}
			
		}
		
	}

	public static long gcd(long x, long y) {
		if (x % y == 0)
			return y;
		else
			return gcd(y, x % y);
	}
	
	private static int BinarySearch(int a[], int low, int high, int target) {
		if (low > high)
			return -1;
		int mid = low + (high - low) / 2;
		if (a[mid] == target)
			return mid;
		if (a[mid] > target)
			high = mid - 1;
		if (a[mid] < target)
			low = mid + 1;
		return BinarySearch(a, low, high, target);
	}
	
	public static String reverseString(String s) {
		StringBuilder sb = new StringBuilder(s);
		sb.reverse();
		return (sb.toString());
	}
	
	private static int GetRightPosition(int A[], int l, int r, int key) {
		int m;

		while (r - l > 1) {
			m = l + (r - l) / 2;

			if (A[m] <= key)
				l = m;
			else
				r = m;
		}

		return l;
	}

	private static int GetLeftPosition(int A[], int l, int r, int key) {
		int m;

		while (r - l > 1) {
			m = l + (r - l) / 2;

			if (A[m] >= key)
				r = m;
			else
				l = m;
		}

		return r;
	}

	private static int CountOccurances(int A[], int size, int key) {
		// Observe boundary conditions
		int left = GetLeftPosition(A, -1, size - 1, key);
		int right = GetRightPosition(A, 0, size, key);

		// What if the element doesn't exists in the array?
		// The checks helps to trace that element exists
		return (A[left] == key && key == A[right]) ? (right - left + 1) : 0;
	}

	private static int Ceil(int a[], int low, int high, int target) {
		if (target <= a[low]) {
			return a[low];

		}
		if (target > a[high])
			return -1;
		while (high - low > 1) {
			int mid = low + (high - low) / 2;
			if (a[mid] < target) {
				low = mid;
				if (mid + 1 <= a.length - 1 && a[mid + 1] >= target)
					return mid + 1;
			}
			if (a[mid] >= target) {
				high = mid;
				if (mid - 1 >= 0 && a[mid - 1] < target) {
					return mid;
				}
			}
		}
		return -1;
	}

	private static int floor(int a[], int low, int high, int target) {
		if (target < a[low]) {
			return -1;
		}
		if (target >= a[high])
			return a[high];
		while (high - low > 1) {
			int mid = low + (high - low) / 2;
			if (a[mid] > target) {
				high = mid;
				if (mid - 1 >= 0 && a[mid - 1] <= target) {
					return mid - 1;
				}
			}
			if (a[mid] <= target) {
				low = mid;
				if ((mid + 1) <= a.length - 1 && a[mid + 1] > target) {
					return mid;
				}
			}

		}
		return -1;
	}

	
	
	public static long pow(long n, long p, long m) {
		long result = 1;
		if (p == 0)
			return 1;
		if (p == 1)
			return n;
		while (p != 0) {
			if (p % 2 == 1)
				result *= n;
			if (result >= m)
				result %= m;
			p >>= 1;
			n *= n;
			if (n >= m)
				n %= m;
		}
		return result;
	}

	public static long pow(long n, long p) {
		long result = 1;
		if (p == 0)
			return 1;
		if (p == 1)
			return n;
		while (p != 0) {
			if (p % 2 == 1)
				result *= n;
			p >>= 1;
			n *= n;
		}
		return result;

	}
	 static void combinationUtil(int arr[], int data[], int start,
             int end, int index, int r)
{
		 // Current combination is ready to be printed, print it
if (index == r)
{
	HashSet hs=new HashSet();
for (int j=0; j<r; j++)
{
	hs.add(data[j]);
//	pw.print(data[j]+" ");
}
//pw.println();
for(int j=0;j<r;j++){
	if(!((j>0&& hs.contains(data[j]-1)) || (j<data.length-1 && hs.contains(data[j]+1)))){
		return;
	}
}
count++;
count%=1000000007;

return;
}

// replace index with all possible elements. The condition
// "end-i+1 >= r-index" makes sure that including one element
// at index will make a combination with remaining elements
// at remaining positions
for (int i=start; i<=end && end-i+1 >= r-index; i++)
{
data[index] = arr[i];
combinationUtil(arr, data, i+1, end, index+1, r);
}
}

// The main function that prints all combinations of size r
// in arr[] of size n. This function mainly uses combinationUtil()
static long printCombination(int arr[], int n, int r)
{
// A temporary array to store all combination one by one
int data[]=new int[r];

// Print all combination using temprary array 'data[]'
combinationUtil(arr, data, 0, n-1, 0, r);
return count;
}

public static long printSubsets(int set[],boolean prime[]) {
		long ans = 0;
		int n = set.length;

		// Run a loop for printing all 2^n
		// subsets one by obe
		for (int i = 0; i < (1 << n); i++) {
			int a[] = new int[n];

			int count = 0;

			// Print current subset
			for (int j = 0; j < n; j++)

				// (1<<j) is a number with jth bit 1
				// so when we 'and' them with the
				// subset number we get which numbers
				// are present in the subset and which
				// are not
				if ((i & (1 << j)) > 0) {

					a[count] = set[j];
					count++;
					//System.out.print(set[j] + " ");
				}
			int tot = 0;
			for (int t = 0; t < count; t++) {
				tot^=a[t];
				pw.print(a[t]+" ");
			}
			//	System.out.println(tot+" "+sum);
			if (prime[tot]) {
				ans++;
				ans%=mod;
			}
			pw.println();
		} //System.out.println(sum+"-sum "+l+" -l");
		return ans;
	}

	// remove N elements in equal steps starting at specific point
	static List<Integer> josephus(int N, int step, int start) {
		if (N < 1 || step < 1 || start < 1)
			return null;

		List<Integer> p = new LinkedList<Integer>();
		for (int i = 0; i < N; i++)
			p.add(i + 1);

		List<Integer> r = new LinkedList<Integer>();
		int i = (start - 2) % N;
		for (int j = N; j > 0; j--) {
			i = (i + step) % N--;
			r.add(p.remove(i--));
		}

		return r;
	}


	public static int[] radixSort(int[] f) {
		int[] to = new int[f.length];
		{
			int[] b = new int[65537];
			for (int i = 0; i < f.length; i++)
				b[1 + (f[i] & 0xffff)]++;
			for (int i = 1; i <= 65536; i++)
				b[i] += b[i - 1];
			for (int i = 0; i < f.length; i++)
				to[b[f[i] & 0xffff]++] = f[i];
			int[] d = f;
			f = to;
			to = d;
		}
		{
			int[] b = new int[65537];
			for (int i = 0; i < f.length; i++)
				b[1 + (f[i] >>> 16)]++;
			for (int i = 1; i <= 65536; i++)
				b[i] += b[i - 1];
			for (int i = 0; i < f.length; i++)
				to[b[f[i] >>> 16]++] = f[i];
			int[] d = f;
			f = to;
			to = d;
		}
		return f;
	}

	public static int nextPowerOf2(final int a) {
		int b = 1;
		while (b < a) {
			b = b << 1;
		}
		return b;
	}

	public static boolean PointInTriangle(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8) {
		int s = p2 * p5 - p1 * p6 + (p6 - p2) * p7 + (p1 - p5) * p8;
		int t = p1 * p4 - p2 * p3 + (p2 - p4) * p7 + (p3 - p1) * p8;

		if ((s < 0) != (t < 0))
			return false;

		int A = -p4 * p5 + p2 * (p5 - p3) + p1 * (p4 - p6) + p3 * p6;
		if (A < 0.0) {
			s = -s;
			t = -t;
			A = -A;
		}
		return s > 0 && t > 0 && (s + t) <= A;
	}

	public static float area(int x1, int y1, int x2, int y2, int x3, int y3) {
		return (float) Math.abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0);
	}

	public static boolean isPrime(int n) {
		// Corner cases
		if (n <= 1)
			return false;
		if (n <= 3)
			return true;

		// This is checked so that we can skip 
		// middle five numbers in below loop
		if (n % 2 == 0 || n % 3 == 0)
			return false;

		for (int i = 5; i * i <= n; i = i + 6)
			if (n % i == 0 || n % (i + 2) == 0)
				return false;

		return true;
	}

	//merge Sort

	static long sort(int a[])
	{  int n=a.length;
		int b[]=new int[n];	
		return mergeSort(a,b,0,n-1);}
	static long mergeSort(int a[],int b[],long left,long right)
	{ long c=0;if(left<right)
	 {   long mid=left+(right-left)/2;
		 c= mergeSort(a,b,left,mid);
		 c+=mergeSort(a,b,mid+1,right);
		 c+=merge(a,b,left,mid+1,right); }	
		return c;	 }
	static long merge(int a[],int  b[],long left,long mid,long right)
	{long c=0;int i=(int)left;int j=(int)mid; int k=(int)left;
	while(i<=(int)mid-1&&j<=(int)right)
	{ if(a[i]>a[j]) {b[k++]=a[i++]; }
	else	{ b[k++]=a[j++];c+=mid-i;}}
	while (i <= (int)mid - 1)   b[k++] = a[i++]; 
	while (j <= (int)right) b[k++] = a[j++];
	for (i=(int)left; i <= (int)right; i++) 
		a[i] = b[i];  return c;  }
	public static boolean isSubSequence(String large, String small, int largeLen, int smallLen) {
		//base cases
		if (largeLen == 0)
			return false;
		if (smallLen == 0)
			return true;
		// If last characters of two strings are matching
		if (large.charAt(largeLen - 1) == small.charAt(smallLen - 1))
			isSubSequence(large, small, largeLen - 1, smallLen - 1);
		// If last characters are not matching
		return isSubSequence(large, small, largeLen - 1, smallLen);
	}

	// To Get Input
	// Some Buffer Methods

	public static void InputReader(InputStream stream1) {
		stream = stream1;
	}

	private static boolean isWhitespace(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private static boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}

	private static int read() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	private static int nextInt() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	private static long nextLong() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	private static String nextToken() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	private static String nextLine() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	private static int[] nextIntArray(int n) {
		int[] arr = new int[n];
		for (int i = 0; i < n; i++) {
			arr[i] = nextInt();
		}
		return arr;
	}

	private static int[][] next2dArray(int n, int m) {
		int[][] arr = new int[n][m];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				arr[i][j] = nextInt();
			}
		}
		return arr;
	}

	private static long[] nextLongArray(int n) {
		long[] arr = new long[n];
		for (int i = 0; i < n; i++) {
			arr[i] = nextLong();
		}
		return arr;
	}

	private static void pArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			pw.print(arr[i] + " ");
		}
		pw.println();
		return;
	}

	private static void pArray(long[] arr) {
		for (int i = 0; i < arr.length; i++) {
			pw.print(arr[i] + " ");
		}
		pw.println();
		return;
	}

	private static void pArray(boolean[] arr) {
		for (int i = 0; i < arr.length; i++) {
			pw.print(arr[i] + " ");
		}
		pw.println();
		return;
	}

	private static boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

	private interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}

	private static void multiply(int a[][], int b[][]) {
		// Creating an auxiliary matrix to store elements 
		// of the multiplication matrix
		int mul[][] = new int[2][2];
		for (int i = 0; i < 2; i++) {
			for (int j = 0; j < 2; j++) {
				mul[i][j] = 0;
				for (int k = 0; k < 2; k++)
					mul[i][j] += a[i][k] * b[k][j];
			}
		}

		// storing the muliplication resul in a[][]
		for (int i = 0; i < 2; i++)
			for (int j = 0; j < 2; j++)
				a[i][j] = mul[i][j]; // Updating our matrix
	}

	// Function to compute F raise to power n-2.
	private static int power(int F[][], long n) {
		int M[][] = { { 1, 1 }, { 1, 0 } };

		// Multiply it with initial values i.e with
		// F(0) = 0, F(1) = 1, F(2) = 1
		if (n == 1)
			return F[0][0] + F[0][1];

		power(F, n / 2);

		multiply(F, F);

		if (n % 2 != 0)
			multiply(F, M);

		// Multiply it with initial values i.e with
		// F(0) = 0, F(1) = 1, F(2) = 1
		return F[0][0] + F[0][1];
	}

	// Return n'th term of a series defined using below
	// recurrence relation.
	// f(n) is defined as
	//			         	    f(n) = f(n-1) + f(n-2) + f(n-3), n>=3
	// Base Cases :
	//			         	    f(0) = 0, f(1) = 1, f(2) = 1
	private static long findNthTerm(long n) {

		int F[][] = { { 1, 1 }, { 1, 0 } };

		return power(F, n - 2);
	}

}
   
    class MyComp implements Comparator<Integer>{

		@Override
		public int compare(Integer o1, Integer o2) {
			if(o1<o2){
				return 1;
			}else if(o1>o2){
				return -1;
			}
			return 0;
		}

		
    	
    }
    class Graph{
    	private long conse=0,co=0,mac_cons_cat=0;
    	private int V,flag=1, d[], road_cond[][];
    	private Stack <Integer>st=new Stack();
    	private LinkedList<Integer > adj[];
    	private HashMap<String ,Integer> hs =new HashMap<>();
    //	boolean Visited[];
Graph(int V){
	V++;

	
	//this.mac_cons_cat=max_cat;
this.V=(V);
adj=new LinkedList[V];
//for(int i=0;i<V;i++)
	//adj[i]=new LinkedList();

	
//Visited=new boolean[V];
 
}
void addEdge(int v,int w,int t){
	if(adj[v]==null){
		adj[v]=new LinkedList();
	}
	adj[v].add(w);
	String temp="";
temp+=v;
temp+=w;
//System.out.println(temp+"---");
	if(!hs.containsKey(temp))
	hs.put(temp, t);

}
public long  bfs(int s)
{
	co=0;
    // Mark all the vertices as not visited(By default
// set as false)
        boolean visited[] = new boolean[V];
 
        // Create a queue for BFS
        LinkedList<Integer> queue = new LinkedList<Integer>();
 
        // Mark the current node as visited and enqueue it
        visited[s]=true;
        queue.add(s);
 
        while (queue.size() != 0)
        {
            // Dequeue a vertex from queue and print it
    s = queue.poll();
   // System.out.print(s+" ");
 
            // Get all adjacent vertices of the dequeued vertex s
    // If a adjacent has not been visited, then mark it
    // visited and enqueue it
        Iterator<Integer> i = adj[s].listIterator();
        while (i.hasNext())
        {
            int n = i.next();
            if (!visited[n])
            {
                visited[n] = true;
                queue.add(n);
            co++;
            }
        }
        return co;
    }
    return 0;
}
 public long  dfs(int startVertex){
	
	boolean Visited[]=new boolean[V];
	
	//flag=1;
	
	 if(!Visited[startVertex])  {
		
		 co=0; 
		 dfsUtil(startVertex,Visited);
	 
	 }
	 
	 return co;
 }
 public void Connected(int v){
	 Iterator<Integer> i = adj[v].listIterator();
	 while(i.hasNext()){
		 int n=i.next();
		 long data=(long)d[n]+(long)d[v];
		 data=data%1000000007;
		 d[n]=(int)data;
	 }
 }
 public int getByte(int v){
	 return d[v];
 }
private void dfsUtil(int startVertex, boolean[] Visited) {
	//System.out.println(pre+" "+startVertex);

Visited[startVertex]=true;


st.push(startVertex);
while(!st.isEmpty()){
	int top=st.pop();
	System.out.print(top+" ");
	
	//System.out.println(top);
Iterator<Integer> i=adj[top].listIterator();

while(i.hasNext()){
	int n=i.next();
//	System.out.println(n+"---");
			 if( !Visited[n]){
				Visited[n]=true;
					st.push(n);
					co++;
					}
			 }
		
	}
		}
}

class Dsu{
	private int rank[], parent[] ,n;
	
	Dsu(int size){
		this.n=size+1;
		rank=new int[n];
		parent=new int[n];
	makeSet();
	}
	
	void makeSet(){
		for(int i=0;i<n;i++){
			parent[i]=i;
		}
	}
	
	int find(int x){
		if(parent[x]!=x){
			
			parent[x]=find(parent[x]);
		}
		return parent[x];
	}	
	
	void union(int x,int y){
		int xRoot=find(x);
		int yRoot=find(y);
		
		if(xRoot==yRoot)
			return;
		if(rank[xRoot]<rank[yRoot]){
		parent[xRoot]=yRoot;	
		}else if(rank[yRoot]<rank[xRoot]){
			parent[yRoot]=xRoot;
		}else{
			parent[yRoot]=xRoot;
			rank[xRoot]++;
		}
		
	}

}