import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class CodeForces {

    private static final BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

    public static void main(String[] args) throws IOException {

        int levels = Integer.parseInt(in.readLine().trim());

        String[] lampCounts = in.readLine().trim().split(" ");

        Node[] nodeList = new Node[(int) (Math.pow(2, levels + 1) - 1)];

        nodeList[0] = new Node(0);
        for (int i = 1; i < nodeList.length; i++) {
            nodeList[i] = new Node(Integer.parseInt(lampCounts[i - 1]));
        }

        for (int i = 1; i < Math.pow(2, levels); i++) {
            nodeList[i - 1].setLeft(nodeList[2 * i - 1]);
            nodeList[i - 1].setRight(nodeList[2 * i]);
        }

        int newLights = 0;
        for (int i = (int) (Math.pow(2, levels) - 2); i >= 0; i--) {
            Node main = nodeList[i], left = main.getLeft(), right = main.getRight();
            int difference = Math.abs((left.getLeftSum() + left.getValue()) - (right.getLeftSum() + right.getValue()));
            newLights += difference;

            if (left.getValue() + left.getLeftSum() < right.getValue() + right.getLeftSum()) {
                left.addValue(difference);
            } else if (left.getValue() + left.getLeftSum() < right.getValue() + right.getLeftSum()) {
                right.addValue(difference);
            }
        }

        System.out.println(newLights);
    }

    private static class Node {

        Node left, right;

        int value;

        public Node(int value) {
            this.value = value;
        }

        public Node getLeft() {
            return left;
        }

        public Node getRight() {
            return right;
        }

        public int getValue() {
            return value;
        }

        public int getLeftSum() {
            int sum = 0;

            if (left != null) {
                sum += left.getLeftSum() + left.getValue();
            }

            return sum;
        }

        public int getSum() {
            int sum = 0;

            if (left != null) {
                sum += left.getSum() + left.getValue();
            }
            if (right != null) {
                sum += right.getSum() + right.getValue();
            }

            return sum;
        }

        public void setLeft(Node left) {
            this.left = left;
        }

        public void setRight(Node right) {
            this.right = right;
        }

        public void addValue(int delta) {
            this.value += delta;
        }
    }

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class CodeForces {

    private static final BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

    public static void main(String[] args) throws IOException {

        int levels = Integer.parseInt(in.readLine().trim());

        String[] lampCounts = in.readLine().trim().split(" ");

        Node[] nodeList = new Node[(int) (Math.pow(2, levels + 1) - 1)];

        nodeList[0] = new Node(0);
        for (int i = 1; i < nodeList.length; i++) {
            nodeList[i] = new Node(Integer.parseInt(lampCounts[i - 1]));
        }

        for (int i = 1; i < Math.pow(2, levels); i++) {
            nodeList[i - 1].setLeft(nodeList[2 * i - 1]);
            nodeList[i - 1].setRight(nodeList[2 * i]);
        }

        int newLights = 0;
        for (int i = (int) (Math.pow(2, levels) - 2); i >= 0; i--) {
            Node main = nodeList[i], left = main.getLeft(), right = main.getRight();
            int difference = Math.abs(left.getSum() / 2 + left.getValue() - (right.getSum() / 2 + right.getValue()));
            newLights += difference;

            if (left.getValue() < right.getValue()) {
                left.addValue(difference);
            } else {
                right.addValue(difference);
            }
        }

        System.out.println(newLights);
    }

    private static class Node {

        Node left, right;

        int value;

        public Node(int value) {
            this.value = value;
        }

        public Node getLeft() {
            return left;
        }

        public Node getRight() {
            return right;
        }

        public int getValue() {
            return value;
        }

        public int getSum() {
            int sum = 0;

            if (left != null) {
                sum += left.getSum() + left.getValue();
            }
            if (right != null) {
                sum += right.getSum() + right.getValue();
            }

            return sum;
        }

        public void setLeft(Node left) {
            this.left = left;
        }

        public void setRight(Node right) {
            this.right = right;
        }

        public void addValue(int delta) {
            this.value += delta;
        }
    }

}


import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Weichao Luo
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskB {
    public void solve(int testNumber, Scanner in, PrintWriter out) {
        int n = in.nextInt();
        int [] a = new int[1 << (n + 1)];
        for (int i = 0; i < ((1 << (n + 1)) - 2); i++) {
            a[i] = in.nextInt();
        }

        int [] need = new int[1 << (n + 1)];

        int extra = 0;
        for (int last = (1 << n) - 1; last >= 1; last --) {
            int left = need[last << 1] + a[(last << 1) - 2];
            int right = need[(last << 1) | 1] + a[((last << 1) | 1) - 2];
            extra += Math.abs(left - right);
            need[last] = Math.max(left, right);
        }
        out.println(extra);
    }
}


import java.util.Collection;
import java.util.Collections;
import java.util.Scanner;

public class Main {
	public static	int[] a;
	public static int[] needed;
	public static int[] passed;
	public static void minimize(int i, int j){
		if (i==0 || i==1 ||i==2 || i==3)
			return;
		if(needed[i]==0 || needed[i+1]==0)
			return;
		int reduction=Math.min(needed[i], needed[i+1]);
		needed[i]-=reduction;
		needed[i+1]-=reduction;
		needed[i/2]+=reduction;
		minimize(i/2,j);
		minStreetLights(j);
	}
public static int minStreetLights(int i){
	if(i==0 )
		return 0;
	int result=minStreetLights(i/2);
	int maxInstalled=0;
	for(int j=i/2; j<i;j++){
		maxInstalled=Math.max(maxInstalled, a[j]);
	}
	for(int j=i/2; j<i;j++){
		needed[j]+=maxInstalled-a[j];
	}
	for(int j=i/2; j<i;j++){
		minimize(j,i);
	}
	return result+maxInstalled;
}

	public static void main(String[] args) {
		Scanner in =new Scanner(System.in);
		int n=in.nextInt();
		a=new int[1<<(n+1)];
		needed=new int[1<<(n+1)];
		passed=new int[1<<(n+1)];
		for(int i=2;i<a.length;i++)
			a[i]=in.nextInt();
		minStreetLights(a.length);
		for(int j=0; j<a.length;j+=2){
			minimize(j);
		}
		int totalNeeded=0;

		for(int i=2;i<a.length;i++)
			totalNeeded+=needed[i];
		System.out.print(totalNeeded);

	}

}


import java.io.*;
import java.util.*;
public class Main {
	public static int nSquares;
	public static int[] lightsfromParent;
	public static long result=0;
	public static void addLights(int s){
		if(s*2>=nSquares){
			return ;
		}
		addLights(2*s);
		addLights(2*s+1);
		result+=Math.abs(lightsfromParent[2*s]-lightsfromParent[2*s+1]);
		lightsfromParent[s]+=Math.max(lightsfromParent[2*s], lightsfromParent[2*s+1]);
	}
	public static void main(String[] args) {
		FastScanner in =new FastScanner();
		PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
		int nRoads=in.nextInt();
		 nSquares=1<<(nRoads+1);
		 lightsfromParent=new int[nSquares];

		for(int iSquare=2;iSquare<nSquares;iSquare++)
			lightsfromParent[iSquare]=in.nextInt();
		addLights(1);
		out.print(result);
		out.close();
	}
	public static class FastScanner{
		BufferedReader br;
		StringTokenizer st;
		public FastScanner(){
			br=new BufferedReader(new InputStreamReader(System.in));
			}
		String next(){
			while(st==null||!st.hasMoreElements())
				try{st=new StringTokenizer(br.readLine());}catch(Exception e){}
			return st.nextToken();
		}
		int nextInt(){return Integer.parseInt(next());}
		long nextLong(){return Long.parseLong(next());}
		double nextDouble(){return Double.parseDouble(next());}
		String nextLine(){
	          String str = "";
			  try {
			     str = br.readLine();
			  } catch (IOException e) {
			     e.printStackTrace();
			  }
			  return str;
	    }
	}
}


import java.util.Collection;
import java.util.Collections;
import java.util.Scanner;

public class Main {
	public static	int[] a;
	public static int[] needed;
	public static int[] passed;
	public static void minimize(int i, int j){
		if (i==0 || i==1 ||i==2 || i==3)
			return;
		if(needed[i]==0 || needed[i+1]==0)
			return;
		int reduction=Math.min(needed[i], needed[i+1]);
		needed[i]-=reduction;
		needed[i+1]-=reduction;
		needed[i/2]+=reduction;
		minimize(i/2,j);
		minStreetLights(j);
	}
public static int minStreetLights(int i){
	if(i==0 )
		return 0;
	int result=minStreetLights(i/2);
	int maxInstalled=0;
	for(int j=i/2; j<i;j++){
		maxInstalled=Math.max(maxInstalled, a[j]);
	}
	for(int j=i/2; j<i;j++){
		needed[j]+=maxInstalled-a[j];
	}
	for(int j=i/2; j<i;j++){
		minimize(j,i);
	}
	return result+maxInstalled;
}

	public static void main(String[] args) {
		Scanner in =new Scanner(System.in);
		int n=in.nextInt();
		a=new int[1<<(n+1)];
		needed=new int[1<<(n+1)];
		passed=new int[1<<(n+1)];
		for(int i=2;i<a.length;i++)
			a[i]=in.nextInt();
		minStreetLights(a.length);

		int totalNeeded=0;

		for(int i=2;i<a.length;i++)
			totalNeeded+=needed[i];
		System.out.print(totalNeeded);

	}

}


import java.io.*;
import java.util.*;
public class Main {
	public static int nSquares;
	public static int[] lightsfromParent;
	public static int[] lightsToExit;
	public static int addedLightsToExit(int s){

		if(s>=nSquares/2){
			lightsToExit[s]=0;

			return 0;
		}

		int addedleft=addedLightsToExit(2*s);
		int addedright=addedLightsToExit(2*s+1);
		int left=lightsToExit[2*s]+lightsfromParent[2*s];
		int right=lightsToExit[2*s+1]+lightsfromParent[2*s+1];
		lightsToExit[s]=Math.max(left, right);
		int previouslyAdded= addedleft+addedright;
		int toBeAdded=Math.abs(left-right);

		int totalAdded=previouslyAdded+toBeAdded;

		return totalAdded;
	}
	public static void main(String[] args) {
		FastScanner in =new FastScanner();
		PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
		int nRoads=in.nextInt();
		 nSquares=1<<(nRoads+1);
		 lightsfromParent=new int[nSquares];
		 lightsToExit=new int[nSquares];

		for(int iSquare=2;iSquare<nSquares;iSquare++)
			lightsfromParent[iSquare]=in.nextInt();
		out.print(addedLightsToExit(1));
		out.close();
	}
	public static class FastScanner{
		BufferedReader br;
		StringTokenizer st;
		public FastScanner(){
			br=new BufferedReader(new InputStreamReader(System.in));
			}
		String next(){
			while(st==null||!st.hasMoreElements())
				try{st=new StringTokenizer(br.readLine());}catch(Exception e){}
			return st.nextToken();
		}
		int nextInt(){return Integer.parseInt(next());}
		long nextLong(){return Long.parseLong(next());}
		double nextDouble(){return Double.parseDouble(next());}
		String nextLine(){
	          String str = "";
			  try {
			     str = br.readLine();
			  } catch (IOException e) {
			     e.printStackTrace();
			  }
			  return str;
	    }
	}
}


import java.util.Collection;
import java.util.Collections;
import java.util.Scanner;

public class Main {
	public static	int[] a;
	public static int[] needed;
	public static void minimize(int i){
		if (i==0 || i==1 ||i==2 || i==3)
			return;
		if(needed[i]==0 || needed[i+1]==0)
			return;
		int reduction=Math.min(needed[i], needed[i+1]);
		needed[i]-=reduction;
		needed[i+1]-=reduction;
		needed[i/2]+=reduction;
		minimize(i/2);
	}
public static int minStreetLights(int i){
	if(i==0 || i==1 ||i==2)
		return 0;
	int result=minStreetLights(i/2);
	int maxInstalled=0;
	for(int j=i/2; j<i;j++){
		maxInstalled=Math.max(maxInstalled, a[j]);
	}
	for(int j=i/2; j<i;j++){
		needed[j]+=maxInstalled-a[j];
	}
	for(int j=i/2; j<i;j+=2){
		minimize(j);
	}
	return result+maxInstalled;
}

	public static void main(String[] args) {
		Scanner in =new Scanner(System.in);
		int n=in.nextInt();
		a=new int[1<<(n+1)];
		needed=new int[1<<(n+1)];
		for(int i=2;i<a.length;i++)
			a[i]=in.nextInt();
		minStreetLights(a.length);
		int totalNeeded=0;
		for(int i=2;i<a.length;i++)
			totalNeeded+=needed[i];
		System.out.print(totalNeeded);

	}

}


import java.util.Collection;
import java.util.Collections;
import java.util.Scanner;

public class Main {
	public static	int[] a;
	public static int[] needed;
	public static int[] passed;
	public static void minimize(int i){
		if (i==0 || i==1 ||i==2 || i==3)
			return;
		if(needed[i]==0 || needed[i+1]==0)
			return;
		int reduction=Math.min(needed[i], needed[i+1]);
		needed[i]-=reduction;
		needed[i+1]-=reduction;
		needed[i/2]+=reduction;
		minimize(i/2);
	}
public static int minStreetLights(int i){
	if(i==0 )
		return 0;
	int result=minStreetLights(i/2);
	int maxInstalled=0;
	for(int j=i/2; j<i;j++){
		maxInstalled=Math.max(maxInstalled, a[j]);
	}
	for(int j=i/2; j<i;j++){
		needed[j]+=maxInstalled-a[j];
	}

	return result+maxInstalled;
}

	public static void main(String[] args) {
		Scanner in =new Scanner(System.in);
		int n=in.nextInt();
		a=new int[1<<(n+1)];
		needed=new int[1<<(n+1)];
		passed=new int[1<<(n+1)];
		for(int i=2;i<a.length;i++)
			a[i]=in.nextInt();
		minStreetLights(a.length);
		for(int j=0; j<a.length;j+=2){
			minimize(j);
		}
		int totalNeeded=0;

		for(int i=2;i<a.length;i++)
			totalNeeded+=needed[i];
		System.out.print(totalNeeded);

	}

}


#include <cstring>
#include <string>
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <list>

using namespace std;

typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vi> vii;
typedef vector<pii> vpii;

#define N 100005

int n,l,v1,v2,k;
ll d,m;
vector<pii> e;
int a[N];
ll ans[N];

int main()
{
#ifdef LocalHost
	freopen("input.txt","r",stdin);
	freopen("output.txt","w",stdout);
#endif
	scanf("%d%d%d%d",&n,&l,&v1,&v2);
	m = v1 + v2;
	d = ll(l) * v2; // /(v1 + v2);
	for(int i = 0; i < n; ++i)
	{
		scanf("%d",&a[i]);
		if(a[i] * m >= d)
		{
			e.push_back(pll(a[i] * m - d,1));
			e.push_back(pll(a[i] * m,-1));
		}else
		{
			e.push_back(pll(0,1));
			e.push_back(pll(a[i] * m,-1));
			e.push_back(pll((2LL*l + a[i]) * m - d,1));
			e.push_back(pll(2LL*l * m,-1));
		}
	}
	sort(e.begin(),e.end());
	k = 0;
	ans[k] += e[0].first;
	for(int i = 0; i < e.size(); ++i)
	{
		if(i > 0)
			ans[k] += e[i].first - e[i-1].first;
		k += e[i].second;
	}
	ans[k] += 2LL*l*m - e.back().first;
	for(int i = 0; i < n+1; ++i)
		printf("%.10lf\n",double(ans[i]) / (m * 2 * l));
	return 0;
}


#include <cstring>
#include <string>
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <list>

using namespace std;

typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vi> vii;
typedef vector<pii> vpii;

#define N 100005

int n,l,v1,v2,k;
ll d,m;
vector<pll> e;
int a[N];
ll ans[N];

int main()
{
#ifdef LocalHost
	freopen("input.txt","r",stdin);
	freopen("output.txt","w",stdout);
#endif
	scanf("%d%d%d%d",&n,&l,&v1,&v2);
	m = v1 + v2;
	d = ll(l) * v2; // /(v1 + v2);
	for(int i = 0; i < n; ++i)
	{
		scanf("%d",&a[i]);
		if(a[i] * m >= d)
		{
			e.push_back(pll(a[i] * m - d,1));
			e.push_back(pll(a[i] * m,-1));
		}else
		{
			e.push_back(pll(0,1));
			e.push_back(pll(a[i] * m,-1));
			e.push_back(pll((2LL*l + a[i]) * m - d,1));
			e.push_back(pll(2LL*l * m,-1));
		}
	}
	sort(e.begin(),e.end());
	k = 0;
	ans[k] += e[0].first;
	for(int i = 0; i < e.size(); ++i)
	{
		if(i > 0)
			ans[k] += e[i].first - e[i-1].first;
		k += e[i].second;
	}
	ans[k] += 2LL*l*m - e.back().first;
	for(int i = 0; i < n+1; ++i)
		printf("%.10lf\n",double(ans[i]) / (m * 2 * l));
	return 0;
}


#include<iostream>
#include<cmath>
#include<algorithm>
#include<string.h>
#include<cstdio>
#include<string>
#include<vector>
//#include<sstream>
#include<map>
#include<set>
//#include<complex>
//#pragma comment(linker, "/STACK:167772160")
#define FOR(i,a,b) for(int i=a;i<=b;++i)
#define pb push_back
#define mp make_pair
#define sz(s) (int)(s).size()
typedef long long Int;
//const int inf=1000000000;
using namespace std;
//const int md=1000000007;
//const double pi=2*acos(0.0);

vector<double> g;
int a[100001];
int n,l,v1,v2;
double ans[100001];

int f(double L,double R)
{
	int k1,k2;

	int l,r;

	l=1;r=n;
	while(r>l)
	{
		int m=(l+r)/2;
		if(a[m]<L)l=m+1;else
			r=m;
	}
	k1=r;
	if(a[k1]<L || a[k1]>=R)return 0;

	l=1;r=n;
	while(r>l)
	{
		int m=(l+r)/2+1;
		if(a[m]>=R)r=m-1;else
			l=m;
	}
	k2=r;
	if(a[k2]<L || a[k2]>=R)return 0;

	if(k1>k2)return 0;
	return k2-k1+1;
}

int main()
{
	//freopen("input.txt","r",stdin);
	cin>>n>>l>>v1>>v2;

	FOR(i,1,n)
		cin>>a[i];

	double dist=(double)v2*(double)l/double(v1+v2);

	sort(a+1,a+n+1);

	g.clear();
	FOR(i,1,n)
		g.pb(a[i]);
	FOR(i,1,n)
		g.pb(a[i]-dist<0?a[i]-dist+2*l:a[i]-dist);
	g.pb(0);
	g.pb(2*l);

	sort(g.begin(),g.end());

	memset(ans,0,sizeof(ans));
	FOR(i,1,sz(g)-1)
	{
		int num=0;
		if(g[i]+dist>2*l)
		{
			num+=f(g[i],2*l);
			num+=f(0,g[i]+dist-2*l);
		}else
			num+=f(g[i],g[i]+dist);

	    ans[num]+=(g[i]-g[i-1])/double(2*l);
	}

	FOR(i,0,n)
		printf("%.10lf\n",ans[i]);

	return 0;
}


#include<iostream>
#include<cmath>
#include<algorithm>
#include<string.h>
#include<cstdio>
#include<string>
#include<vector>
//#include<sstream>
#include<map>
#include<set>
//#include<complex>
//#pragma comment(linker, "/STACK:167772160")
#define FOR(i,a,b) for(int i=a;i<=b;++i)
#define pb push_back
#define mp make_pair
#define sz(s) (int)(s).size()
typedef long long Int;
//const int inf=1000000000;
using namespace std;
//const int md=1000000007;
//const double pi=2*acos(0.0);

vector<double> g;
vector<int> G;
int a[100001];
int n,l,v1,v2;
double ans[100001];

int f(double L,double R)
{
	int k1,k2;

	int l,r;

	l=1;r=n;
	while(r>l)
	{
		int m=(l+r)/2;
		if(a[m]<L)l=m+1;else
			r=m;
	}
	k1=r;
	if(a[k1]<L || a[k1]>=R)return 0;

	l=1;r=n;
	while(r>l)
	{
		int m=(l+r)/2+1;
		if(a[m]>=R)r=m-1;else
			l=m;
	}
	k2=r;
	if(a[k2]<L || a[k2]>=R)return 0;

	if(k1>k2)return 0;
	return k2-k1+1;
}

int F(int L,int R)
{
	int k1,k2;

	int l,r;

	l=1;r=n;
	while(r>l)
	{
		int m=(l+r)/2;
		if(a[m]<L)l=m+1;else
			r=m;
	}
	k1=r;
	if(a[k1]<L || a[k1]>=R)return 0;

	l=1;r=n;
	while(r>l)
	{
		int m=(l+r)/2+1;
		if(a[m]>=R)r=m-1;else
			l=m;
	}
	k2=r;
	if(a[k2]<L || a[k2]>=R)return 0;

	if(k1>k2)return 0;
	return k2-k1+1;
}

int main()
{
	//freopen("input.txt","r",stdin);
	cin>>n>>l>>v1>>v2;

	FOR(i,1,n)
		cin>>a[i];

	if(((Int)v2*l)%(v1+v2)!=0)
	{

	double dist=(Int)v2*(Int)l/double(v1+v2);

	sort(a+1,a+n+1);

	g.clear();
	FOR(i,1,n)
		g.pb(a[i]);
	FOR(i,1,n)
		g.pb(a[i]-dist<0?a[i]-dist+2*l:a[i]-dist);
	g.pb(0);
	g.pb(2*l);

	sort(g.begin(),g.end());

	memset(ans,0,sizeof(ans));
	FOR(i,1,sz(g)-1)
	{
		int num=0;
		if(g[i]+dist>=2*l)
		{
			num+=f(g[i],2*l);
			num+=f(0,g[i]+dist-2*l);
		}else
			num+=f(g[i],g[i]+dist);

	    ans[num]+=(g[i]-g[i-1])/double(2*l);

	}
	}else
	{

	int dist=(Int)v2*(Int)l/(v1+v2);

	sort(a+1,a+n+1);

	G.clear();
	FOR(i,1,n)
		G.pb(a[i]);
	FOR(i,1,n)
		G.pb(a[i]-dist<0?a[i]-dist+2*l:a[i]-dist);
	G.pb(0);
	G.pb(2*l);

	sort(G.begin(),G.end());

	memset(ans,0,sizeof(ans));
	FOR(i,1,sz(G)-1)
	{
		int num=0;
		if(G[i]+dist>=2*l)
		{
			num+=f(G[i],2*l);
			num+=f(0,G[i]+dist-2*l);
		}else
			num+=f(G[i],G[i]+dist);

		//cout<<g[i]<<" "<<g[i-1]<<" "<<num<<endl;
	    ans[num]+=(G[i]-G[i-1])/double(2*l);

		//cout<<ans[num]<<endl;
	}
	}

	FOR(i,0,n)
		printf("%.10lf\n",ans[i]);

	return 0;
}


#pragma comment(linker,"/STACK:128000000")
#include <cstdio>
#include <memory>
#include <algorithm>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <complex>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#include <iostream>
#include <fstream>
#include <functional>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int ui;
typedef unsigned char uc;
typedef short int si;
typedef unsigned short int usi;
typedef long double ld;
typedef pair<int,int> pii;
//typedef pair<ll,ll> pll;

#define rep(x,y,z) for(int x=(y),e##x=(z);x<e##x;x++)
#define all(x) (x).begin(),(x).end()
#define movmax(A,B) {if(A<(B)) A=(B);}
#define movmin(A,B) {if(A>(B)) A=(B);}
//#define x first
//#define y second

const double PI=acos(-1.0);
template<class T> T SQR(const T &a){return a*a;}

typedef pair<ll,int> pll;

int main()
{
	int n,l,v1,v2;
	cin>>n>>l>>v1>>v2;
	ll d=l*ll(v2);
	ll M=2*l*ll(v1+v2);
	pll A[200200];
	rep(i,0,n)
	{
		scanf("%I64d",&A[i].first);
		A[i].first*=(v1+v2);
		A[i].second=-1;
	}
	rep(i,0,n)
		A[i+n]=pii((A[i].first-d+M)%M,1);
	sort(A,A+2*n);
	A[2*n]=A[0];
	ll Ans[100100]={0};
	int pos=0;
	int cnt=0;
	while (pos<2*n && A[pos].first<d)
	{
		if (A[pos].second==-1) cnt++;
		pos++;
	}
	rep(i,0,2*n)
	{
		cnt+=A[i].second;
		Ans[cnt]+=(A[i+1].first-A[i].first+M)%M;

	}
	rep(i,0,n+1)
		printf("%.10lf\n",Ans[i]/double(M));
	return 0;
}

/*
ab
adb
*/


#pragma comment(linker,"/STACK:128000000")
#include <cstdio>
#include <memory>
#include <algorithm>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <complex>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#include <iostream>
#include <fstream>
#include <functional>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int ui;
typedef unsigned char uc;
typedef short int si;
typedef unsigned short int usi;
typedef long double ld;
typedef pair<int,int> pii;
//typedef pair<ll,ll> pll;

#define rep(x,y,z) for(int x=(y),e##x=(z);x<e##x;x++)
#define all(x) (x).begin(),(x).end()
#define movmax(A,B) {if(A<(B)) A=(B);}
#define movmin(A,B) {if(A>(B)) A=(B);}
//#define x first
//#define y second

const double PI=acos(-1.0);
template<class T> T SQR(const T &a){return a*a;}

typedef pair<ll,int> pll;

int main()
{
	int n,l,v1,v2;
	cin>>n>>l>>v1>>v2;
	ll d=l*ll(v2);
	ll M=2*l*ll(v1+v2);
	pll A[200200];
	rep(i,0,n)
	{
		cin>>A[i].first;
		A[i].first*=(v1+v2);
		A[i].second=-1;
	}
	rep(i,0,n)
		A[i+n]=pll((A[i].first-d+M)%M,1);
	sort(A,A+2*n);
	A[2*n]=A[0];
	ll Ans[100100]={0};
	int pos=0;
	int cnt=0;
	while (pos<2*n && A[pos].first<d)
	{
		if (A[pos].second==-1) cnt++;
		pos++;
	}
	rep(i,0,2*n)
	{
		cnt+=A[i].second;
		ll curr=(A[i+1].first-A[i].first)%M;
		if (curr<0) curr+=M;
		Ans[cnt]+=curr;
	}
	rep(i,0,n+1)
		printf("%.10lf\n",Ans[i]/double(M));
	return 0;
}

/*
ab
adb
*/


#pragma comment(linker,"/STACK:128000000")
#include <cstdio>
#include <memory>
#include <algorithm>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <complex>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#include <iostream>
#include <fstream>
#include <functional>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int ui;
typedef unsigned char uc;
typedef short int si;
typedef unsigned short int usi;
typedef long double ld;
typedef pair<int,int> pii;
//typedef pair<ll,ll> pll;

#define rep(x,y,z) for(int x=(y),e##x=(z);x<e##x;x++)
#define all(x) (x).begin(),(x).end()
#define movmax(A,B) {if(A<(B)) A=(B);}
#define movmin(A,B) {if(A>(B)) A=(B);}
//#define x first
//#define y second

const double PI=acos(-1.0);
template<class T> T SQR(const T &a){return a*a;}

typedef pair<ll,int> pll;

int main()
{
	int n,l,v1,v2;
	cin>>n>>l>>v1>>v2;
	ll d=l*ll(v2);
	ll M=2*l*ll(v1+v2);
	pll A[200200];
	rep(i,0,n)
	{
		cin>>A[i].first;
		A[i].first*=(v1+v2);
		A[i].second=-1;
	}
	rep(i,0,n)
		A[i+n]=pii((A[i].first-d+M)%M,1);
	sort(A,A+2*n);
	A[2*n]=A[0];
	ll Ans[100100]={0};
	int pos=0;
	int cnt=0;
	while (pos<2*n && A[pos].first<d)
	{
		if (A[pos].second==-1) cnt++;
		pos++;
	}
	rep(i,0,2*n)
	{
		cnt+=A[i].second;
		ll curr=(A[i+1].first-A[i].first)%M;
		if (curr<0) curr+=M;
		Ans[cnt]+=M;
	}
	rep(i,0,n+1)
		printf("%.10lf\n",Ans[i]/double(M));
	return 0;
}

/*
ab
adb
*/


#pragma comment(linker,"/STACK:128000000")
#include <cstdio>
#include <memory>
#include <algorithm>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <complex>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#include <iostream>
#include <fstream>
#include <functional>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int ui;
typedef unsigned char uc;
typedef short int si;
typedef unsigned short int usi;
typedef long double ld;
typedef pair<int,int> pii;
//typedef pair<ll,ll> pll;

#define rep(x,y,z) for(int x=(y),e##x=(z);x<e##x;x++)
#define all(x) (x).begin(),(x).end()
#define movmax(A,B) {if(A<(B)) A=(B);}
#define movmin(A,B) {if(A>(B)) A=(B);}
//#define x first
//#define y second

const double PI=acos(-1.0);
template<class T> T SQR(const T &a){return a*a;}

typedef pair<ll,int> pll;

int main()
{
	int n,l,v1,v2;
	cin>>n>>l>>v1>>v2;
	ll d=l*ll(v2);
	ll M=2*l*ll(v1+v2);
	pll A[200200];
	rep(i,0,n)
	{
		cin>>A[i].first;
		A[i].first*=(v1+v2);
		A[i].second=-1;
	}
	rep(i,0,n)
		A[i+n]=pii((A[i].first-d+M)%M,1);
	sort(A,A+2*n);
	A[2*n]=A[0];
	ll Ans[100100]={0};
	int pos=0;
	int cnt=0;
	while (pos<2*n && A[pos].first<d)
	{
		if (A[pos].second==-1) cnt++;
		pos++;
	}
	rep(i,0,2*n)
	{
		cnt+=A[i].second;
		ll curr=(A[i+1].first-A[i].first)%M;
		if (curr<0) curr+=M;
		Ans[cnt]+=curr;
	}
	rep(i,0,n+1)
		printf("%.10lf\n",Ans[i]/double(M));
	return 0;
}

/*
ab
adb
*/


R=lambda:map(int,raw_input().split())
n,l,v1,v2=R()
s=v2*l
v1+=v2
l*=v1*2
a=[x*v1 for x in R()]
p,v,i,j=0,0,0,0
c=[0]*(n+1)
b=a[:]
for x in a:b+=[y for y in (x-s,x-s+l,x+l) if 0<=y<l]
b.sort()
b+=[l]
a+=[x+l for x in a]+[a[0]+l*2]
while a[j]<s:j+=1
for x in b:
  c[j-i]+=x-p
  while a[i]<=x:i+=1
  while a[j]<=x+s:j+=1
  p=x
for x in c:print x/1./l


def s():
	I=lambda:map(int,raw_input().split())
	n,l,v,V=I()
	a=I()
	g=lambda i:a[i%n]+(i/n*2*l)
	r=[0]*(n+1)
	d=V*l/(0.+v+V)
	if d>=2*l:r[n]=1;return
	pl=pr=0
	while g(pl)+d>=g(pr+1):pr+=1
	pL=g(pl)
	state=0
	while 1:
		pd=pr-pl+state
		if state==0:
			if g(pl+1)+d<=g(pr+1): pl+=1; state=0
			else: pr+=1; state=1
		else:
			if g(pl)+d<=g(pr+1): state=0
			else: pr+=1; state=1
		if state and g(pl)+d<g(pr):pl+=1
		pL_=g(pr)-d if state else g(pl)
		r[pd]+=(pL_-pL)/(2.*l)
		pL=pL_
		if pl==n and state==0:break
	return r
for i in s():print "%.20f"%i


using System;
using System.Text;
using System.IO;
using System.Diagnostics;
using System.Globalization;
using System.Collections.Generic;
using System.Threading;
using System.Linq;

namespace CodeForces
{
	class C
	{
		class Evt : IComparable<Evt>
		{
			public long X { get; set; }
			public int Type { get; set; }
			public int CompareTo( Evt other )
			{
				if ( X != other.X ) return X.CompareTo( other.X );
				return Type.CompareTo( other.Type );
			}
		}
		private void Solve()
		{
			int n = NextInt(), l = NextInt(), v1 = NextInt(), v2 = NextInt();
			int[] a = new int[n];
			for ( int i = 0; i < n; ++i ) a[i] = NextInt();

			long len = (long)l * v2;
			long[] x = new long[2 * n];
			for ( int i = 0; i < n; ++i )
			{
				x[i] = (long)a[i] * ( v1 + v2 );
				x[i + n] = (long)( a[i] + 2 * l ) * ( v1 + v2 );
			}

			var events = new List<Evt>();
			long mx = 2L * l * ( v1 + v2 );
			foreach ( var xx in x )
			{
				if ( xx < mx ) events.Add( new Evt { Type = 0, X = xx } );
				if ( xx - len >= 0 && xx - len < mx ) events.Add( new Evt { Type = 1, X = xx - len } );
			}
			events.Sort();

			int cur = 0;
			foreach ( var xx in x )
			{
				if ( xx < len ) ++cur;
			}
			long[] sums = new long[n + 1];
			var first = true;
			long lastX = 0;
			foreach ( var e in events )
			{
				sums[cur] += e.X - lastX;
				if ( e.Type == 0 )
				{
					--cur;
				}
				else
				{
					++cur;
				}
				lastX = e.X;
			}
			sums[cur] += mx - lastX;

			for ( int i = 0; i <= n; ++i )
			{
				Out.WriteLine( ( (double)sums[i] / mx ).ToString( "0.000000000000", CultureInfo.InvariantCulture ) );
			}
		}

		#region Local wireup

		public int NextInt()
		{
			return _in.NextInt();
		}

		public long NextLong()
		{
			return _in.NextLong();
		}

		public string NextLine()
		{
			return _in.NextLine();
		}

		public double NextDouble()
		{
			return _in.NextDouble();
		}

		readonly Scanner _in = new Scanner();
		static readonly TextWriter Out = Console.Out;

		void Start()
		{
#if !ONLINE_JUDGE
			var timer = new Stopwatch();
			timer.Start();
#endif
			var t = new Thread( Solve, 20000000 );
			t.Start();
			t.Join();
#if !ONLINE_JUDGE
			timer.Stop();
			Console.WriteLine( string.Format( CultureInfo.InvariantCulture, "Done in {0} seconds.\nPress <Enter> to exit.", timer.ElapsedMilliseconds / 1000.0 ) );
			Console.ReadLine();
#endif
		}

		static void Main()
		{
			new C().Start();
		}

		class Scanner : IDisposable
		{
			#region Fields

			readonly TextReader _reader;
			readonly int _bufferSize;
			readonly bool _closeReader;
			readonly char[] _buffer;
			int _length, _pos;

			#endregion

			#region .ctors

			public Scanner( TextReader reader, int bufferSize, bool closeReader )
			{
				_reader = reader;
				_bufferSize = bufferSize;
				_closeReader = closeReader;
				_buffer = new char[_bufferSize];
				FillBuffer( false );
			}

			public Scanner( TextReader reader, bool closeReader ) : this( reader, 1 << 16, closeReader ) { }

			public Scanner( string fileName ) : this( new StreamReader( fileName, Encoding.Default ), true ) { }

#if ONLINE_JUDGE
			public Scanner() : this( Console.In, false ) { }
#else
			public Scanner() : this( "input.txt" ) { }
#endif

			#endregion

			#region IDisposable Members

			public void Dispose()
			{
				if ( _closeReader )
				{
					_reader.Close();
				}
			}

			#endregion

			#region Properties

			public bool Eof
			{
				get
				{
					if ( _pos < _length ) return false;
					FillBuffer( false );
					return _pos >= _length;
				}
			}

			#endregion

			#region Methods

			private char NextChar()
			{
				if ( _pos < _length ) return _buffer[_pos++];
				FillBuffer( true );
				return _buffer[_pos++];
			}

			private char PeekNextChar()
			{
				if ( _pos < _length ) return _buffer[_pos];
				FillBuffer( true );
				return _buffer[_pos];
			}

			private void FillBuffer( bool throwOnEof )
			{
				_length = _reader.Read( _buffer, 0, _bufferSize );
				if ( throwOnEof && Eof )
				{
					throw new IOException( "Can't read beyond the end of file" );
				}
				_pos = 0;
			}

			public int NextInt()
			{
				var neg = false;
				int res = 0;
				SkipWhitespaces();
				if ( !Eof && PeekNextChar() == '-' )
				{
					neg = true;
					_pos++;
				}
				while ( !Eof && !IsWhitespace( PeekNextChar() ) )
				{
					var c = NextChar();
					if ( c < '0' || c > '9' ) throw new ArgumentException( "Illegal character" );
					res = 10 * res + c - '0';
				}
				return neg ? -res : res;
			}

			public long NextLong()
			{
				var neg = false;
				long res = 0;
				SkipWhitespaces();
				if ( !Eof && PeekNextChar() == '-' )
				{
					neg = true;
					_pos++;
				}
				while ( !Eof && !IsWhitespace( PeekNextChar() ) )
				{
					var c = NextChar();
					if ( c < '0' || c > '9' ) throw new ArgumentException( "Illegal character" );
					res = 10 * res + c - '0';
				}
				return neg ? -res : res;
			}

			public string NextLine()
			{
				SkipUntilNextLine();
				if ( Eof ) return "";
				var builder = new StringBuilder();
				while ( !Eof && !IsEndOfLine( PeekNextChar() ) )
				{
					builder.Append( NextChar() );
				}
				return builder.ToString();
			}

			public double NextDouble()
			{
				SkipWhitespaces();
				var builder = new StringBuilder();
				while ( !Eof && !IsWhitespace( PeekNextChar() ) )
				{
					builder.Append( NextChar() );
				}
				return double.Parse( builder.ToString(), CultureInfo.InvariantCulture );
			}

			private void SkipWhitespaces()
			{
				while ( !Eof && IsWhitespace( PeekNextChar() ) )
				{
					++_pos;
				}
			}

			private void SkipUntilNextLine()
			{
				while ( !Eof && IsEndOfLine( PeekNextChar() ) )
				{
					++_pos;
				}
			}

			private static bool IsWhitespace( char c )
			{
				return c == ' ' || c == '\t' || c == '\n' || c == '\r';
			}

			private static bool IsEndOfLine( char c )
			{
				return c == '\n' || c == '\r';
			}

			#endregion
		}

		#endregion
	}
}


using System;
using System.Text;
using System.IO;
using System.Diagnostics;
using System.Globalization;
using System.Collections.Generic;
using System.Threading;
using System.Linq;

namespace CodeForces
{
	class C
	{
		class Evt : IComparable<Evt>
		{
			public long X { get; set; }
			public int Type { get; set; }
			public int CompareTo( Evt other )
			{
				if ( X != other.X ) return X.CompareTo( other.X );
				return Type.CompareTo( other.Type );
			}
		}
		private void Solve()
		{
			int n = NextInt(), l = NextInt(), v1 = NextInt(), v2 = NextInt();
			int[] a = new int[n];
			for ( int i = 0; i < n; ++i ) a[i] = NextInt();

			long len = (long)l * v2;
			long[] x = new long[2 * n];
			for ( int i = 0; i < n; ++i )
			{
				x[i] = (long)a[i] * ( v1 + v2 );
				x[i + n] = ( a[i] + 2L * l ) * ( v1 + v2 );
			}

			var events = new List<Evt>();
			long mx = 2L * l * ( v1 + v2 );
			foreach ( var xx in x )
			{
				if ( xx < mx ) events.Add( new Evt { Type = 0, X = xx } );
				if ( xx - len >= 0 && xx - len < mx ) events.Add( new Evt { Type = 1, X = xx - len } );
			}
			events.Sort();

			int cur = 0;
			foreach ( var xx in x )
			{
				if ( xx < len ) ++cur;
			}
			long[] sums = new long[n + 1];
			var first = true;
			long lastX = 0;
			foreach ( var e in events )
			{
				sums[cur] += e.X - lastX;
				if ( e.Type == 0 )
				{
					--cur;
				}
				else
				{
					++cur;
				}
				lastX = e.X;
			}
			sums[cur] += mx - lastX;
			for ( int i = 0; i <= n; ++i )
			{
				Out.WriteLine( ( (double)sums[i] / mx ).ToString( "0.000000000000", CultureInfo.InvariantCulture ) );
			}
		}

		#region Local wireup

		public int NextInt()
		{
			return _in.NextInt();
		}

		public long NextLong()
		{
			return _in.NextLong();
		}

		public string NextLine()
		{
			return _in.NextLine();
		}

		public double NextDouble()
		{
			return _in.NextDouble();
		}

		readonly Scanner _in = new Scanner();
		static readonly TextWriter Out = Console.Out;

		void Start()
		{
#if !ONLINE_JUDGE
			var timer = new Stopwatch();
			timer.Start();
#endif
			var t = new Thread( Solve, 20000000 );
			t.Start();
			t.Join();
#if !ONLINE_JUDGE
			timer.Stop();
			Console.WriteLine( string.Format( CultureInfo.InvariantCulture, "Done in {0} seconds.\nPress <Enter> to exit.", timer.ElapsedMilliseconds / 1000.0 ) );
			Console.ReadLine();
#endif
		}

		static void Main()
		{
			new C().Start();
		}

		class Scanner : IDisposable
		{
			#region Fields

			readonly TextReader _reader;
			readonly int _bufferSize;
			readonly bool _closeReader;
			readonly char[] _buffer;
			int _length, _pos;

			#endregion

			#region .ctors

			public Scanner( TextReader reader, int bufferSize, bool closeReader )
			{
				_reader = reader;
				_bufferSize = bufferSize;
				_closeReader = closeReader;
				_buffer = new char[_bufferSize];
				FillBuffer( false );
			}

			public Scanner( TextReader reader, bool closeReader ) : this( reader, 1 << 16, closeReader ) { }

			public Scanner( string fileName ) : this( new StreamReader( fileName, Encoding.Default ), true ) { }

#if ONLINE_JUDGE
			public Scanner() : this( Console.In, false ) { }
#else
			public Scanner() : this( "input.txt" ) { }
#endif

			#endregion

			#region IDisposable Members

			public void Dispose()
			{
				if ( _closeReader )
				{
					_reader.Close();
				}
			}

			#endregion

			#region Properties

			public bool Eof
			{
				get
				{
					if ( _pos < _length ) return false;
					FillBuffer( false );
					return _pos >= _length;
				}
			}

			#endregion

			#region Methods

			private char NextChar()
			{
				if ( _pos < _length ) return _buffer[_pos++];
				FillBuffer( true );
				return _buffer[_pos++];
			}

			private char PeekNextChar()
			{
				if ( _pos < _length ) return _buffer[_pos];
				FillBuffer( true );
				return _buffer[_pos];
			}

			private void FillBuffer( bool throwOnEof )
			{
				_length = _reader.Read( _buffer, 0, _bufferSize );
				if ( throwOnEof && Eof )
				{
					throw new IOException( "Can't read beyond the end of file" );
				}
				_pos = 0;
			}

			public int NextInt()
			{
				var neg = false;
				int res = 0;
				SkipWhitespaces();
				if ( !Eof && PeekNextChar() == '-' )
				{
					neg = true;
					_pos++;
				}
				while ( !Eof && !IsWhitespace( PeekNextChar() ) )
				{
					var c = NextChar();
					if ( c < '0' || c > '9' ) throw new ArgumentException( "Illegal character" );
					res = 10 * res + c - '0';
				}
				return neg ? -res : res;
			}

			public long NextLong()
			{
				var neg = false;
				long res = 0;
				SkipWhitespaces();
				if ( !Eof && PeekNextChar() == '-' )
				{
					neg = true;
					_pos++;
				}
				while ( !Eof && !IsWhitespace( PeekNextChar() ) )
				{
					var c = NextChar();
					if ( c < '0' || c > '9' ) throw new ArgumentException( "Illegal character" );
					res = 10 * res + c - '0';
				}
				return neg ? -res : res;
			}

			public string NextLine()
			{
				SkipUntilNextLine();
				if ( Eof ) return "";
				var builder = new StringBuilder();
				while ( !Eof && !IsEndOfLine( PeekNextChar() ) )
				{
					builder.Append( NextChar() );
				}
				return builder.ToString();
			}

			public double NextDouble()
			{
				SkipWhitespaces();
				var builder = new StringBuilder();
				while ( !Eof && !IsWhitespace( PeekNextChar() ) )
				{
					builder.Append( NextChar() );
				}
				return double.Parse( builder.ToString(), CultureInfo.InvariantCulture );
			}

			private void SkipWhitespaces()
			{
				while ( !Eof && IsWhitespace( PeekNextChar() ) )
				{
					++_pos;
				}
			}

			private void SkipUntilNextLine()
			{
				while ( !Eof && IsEndOfLine( PeekNextChar() ) )
				{
					++_pos;
				}
			}

			private static bool IsWhitespace( char c )
			{
				return c == ' ' || c == '\t' || c == '\n' || c == '\r';
			}

			private static bool IsEndOfLine( char c )
			{
				return c == '\n' || c == '\r';
			}

			#endregion
		}

		#endregion
	}
}


import sys
range = xrange
input = raw_input

n,L,v1,v2 = [int(x) for x in input().split()]

L2 = 2 * L
L3 = 3 * L
n2 = 2 * n

l = L/(1.0 + v1*1.0/v2)

A = [int(x) for x in input().split()]
B = [a + L3 for a in A]
A += [a + L2 for a in A]
A += B

x = 0.0
i = 0
j = 0
count = [0.0]*(n + 1)

while j < n2 and A[j] < x + l:
    j += 1

while x != L2:
    nextx = min(A[j] - l, A[i], L2)
    count[j - i] += nextx - x
    if nextx == A[i]:
        i += 1
    elif nextx != L2:
        j += 1
    x = nextx

print '\n'.join(str(x / L2) for x in count)


#include <set>
#include <iostream>
#include <algorithm>

using namespace std;

int main() {
    int n;
    long long m, d, v1, v2;
    vector<long long> v, w, p;

    cin >> n;
    cin >> m >> v1 >> v2;
    v.resize(n);
    for (int i = 0; i < n; ++i) {
        cin >> v[i];
        v[i] *= v1 + v2;
    }
    d = m * v2;
    m = 2 * m * (v1 + v2);

    sort(v.begin(), v.end());
    for (int i = 0; i < n; ++i) {
        v.push_back(v[i] + m);
    }
    p.push_back(0);
    p.push_back(m);
    for (long long i: v) {
        // cout << i << " ";
        if (i < m) {
            p.push_back(i);
        }
        if (0 <= i - d && i - d < m) {
            p.push_back(i - d);
        }
    }
    // cout << endl;
    sort(p.begin(), p.end());
    p.erase(unique(p.begin(), p.end()), p.end());

    w.resize(n + 1);
    for (int i = 1; i < (int)p.size(); ++i) {
        int l = upper_bound(v.begin(), v.end(), p[i - 1]) - v.begin();
        int r = upper_bound(v.begin(), v.end(), p[i - 1] + d) - v.begin();
        // cout << p[i - 1] << " " << p[i] << ": " << r << " - " << l << endl;
        w[r - l] += p[i] - p[i - 1];
    }
    for (long long i: w) {
        printf("%.16lf\n", 1.0 * i / m);
    }

    return 0;
}


#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <string>
#include <cstring>
#include <set>
#include <map>
using namespace std;

typedef long double ld;
const ld eps = 1e-12;

const int maxn = 100005;
ld ans[maxn];
int n;
ld l, v1, v2;
ld t, s;

pair<ld, int> ev[maxn*2];
int esz = 0;

int main()
{
#ifdef moskupols
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif

	cin >> n >> l >> v1 >> v2;
	s = l * v1 / (v1+v2);
	t = (l-s) / v1;
	ld period = 2.*l/v1;
	int startbal = 0;
	for (int i = 0; i < n; ++i)
	{
		ld a;
		cin >> a;
		ld start = -a / v1;
		ld final = start + t;
		if (start < -eps)
			start += period;
		if (final < -eps)
			final += period;
		ev[esz++] = make_pair(start,1);
		ev[esz++] = make_pair(final,-1);
		if (final < start)
			startbal++;
	}

	ev[esz++] = make_pair(-eps, 0);
	ev[esz++] = make_pair(period, 0);
	sort(ev, ev + esz);

	int bal = startbal;
	for (int i = 1; i < esz; ++i)
	{
		ans[bal] += ev[i].first - ev[i-1].first;
		bal += ev[i].second;
	}

	cout.precision(12);
	for (int i = 0; i <= n; ++i)
		cout << ans[i] / period << endl;

	return 0;
}


#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <string>
#include <cstring>
#include <set>
#include <map>
using namespace std;

typedef long double ld;
const ld eps = 1e-15;

const int maxn = 100005;
ld ans[maxn];
int n;
ld l, v1, v2;
ld t, s;

pair<ld, int> ev[maxn*2];
int esz = 0;

int main()
{
#ifdef moskupols
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif

	cin >> n >> l >> v1 >> v2;
	s = l * v1 / (v1+v2);
	t = (l-s) / v1;
	ld period = 2.*l/v1;
	int startbal = 0;
	for (int i = 0; i < n; ++i)
	{
		ld a;
		cin >> a;
		ld start = -a / v1;
		ld final = start + t;
		if (start < -eps)
			start += period;
		if (final < -eps)
			final += period;
		ev[esz++] = make_pair(start,1);
		ev[esz++] = make_pair(final,-1);
		if (final < start)
			startbal++;
	}

	ev[esz++] = make_pair(-eps, 0);
	ev[esz++] = make_pair(period, 0);
	sort(ev, ev + esz);

	int bal = startbal;
	for (int i = 1; i < esz; ++i)
	{
		ans[bal] += ev[i].first - ev[i-1].first;
		bal += ev[i].second;
	}

	cout.precision(12);
	for (int i = 0; i <= n; ++i)
		cout << ans[i] / period << endl;

	return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define ll int
#define pi pair<double,ll>
#define pii pair<ll,pi>
#define mp make_pair
#define mod 1000000007
#define f first
#define s second
#define pb push_back
#define fr freopen("input-20.txt","r",stdin)
#define fo freopen("output-20.txt","w",stdout)
int main(){
   ll n,l,v1,v2;
   cin>>n>>l>>v1>>v2;
   double d=v2*l;
   d/=(double)(v1+v2);
   vector<pi>p;
   double x,h;
   for(int i=0;i<n;i++){
        cin>>x;
        h=x-d;
        if(h<0){
            p.pb({0,1});
            p.pb({x,-1});
            p.pb({2*l+h,1});
            p.pb({2*l,-1});
        }
        else{
            p.pb({h,1});
            p.pb({x,-1});
        }
   }
   p.pb({0,0});
   p.pb({2*l,0});
   sort(p.begin(),p.end());
   ll cnt=0;
   double prev=0;
   double res[100011]={0};
   for(int i=0;i<p.size();i++){
        if(i>0)
        res[cnt]+=p[i].f-prev;
        prev=p[i].f;
        cnt+=p[i].s;
   }
   for(int i=0;i<=n;i++){
    printf("%.10f ",res[i]/(2.0*(double)l));
   }
}


#include<bits/stdc++.h>
using namespace std;
#define ll int
#define pi pair<double,ll>
#define pii pair<ll,pi>
#define mp make_pair
#define mod 1000000007
#define f first
#define s second
#define pb push_back
#define fr freopen("input-20.txt","r",stdin)
#define fo freopen("output-20.txt","w",stdout)
int main(){
   ll n,l,v1,v2;
   cin>>n>>l>>v1>>v2;
   double d=v2*l;
   d/=(double)(v1+v2);
   vector<pi>p;
   double x,h;
   for(int i=0;i<n;i++){
        cin>>x;
        h=x-d;
        if(h<0){
            p.pb({0,1});
            p.pb({x,-1});
            p.pb({2*l+h,1});
            p.pb({2*l,-1});
        }
        else{
            p.pb({h,1});
            p.pb({x,-1});
        }
   }
   p.pb({0,0});
   p.pb({2*l,0});
   sort(p.begin(),p.end());
   ll cnt=0;
   double prev=0;
   double res[100011]={0};
   for(int i=0;i<p.size();i++){
        res[cnt]+=p[i].f-prev;
        prev=p[i].f;
        cnt+=p[i].s;
   }
   for(int i=0;i<=n;i++){
    printf("%.10f ",res[i]/(2.0*l));
   }
}


#include<bits/stdc++.h>
using namespace std;
#define ll int
#define pi pair<double,ll>
#define pii pair<ll,pi>
#define mp make_pair
#define mod 1000000007
#define f first
#define s second
#define pb push_back
#define fr freopen("input-20.txt","r",stdin)
#define fo freopen("output-20.txt","w",stdout)
int main(){
   ll n;
   double l,v1,v2;
   cin>>n>>l>>v1>>v2;
   double d=v2*l;
   d/=(double)(v1+v2);
   vector<pi>p;
   double x,h;
   for(int i=0;i<n;i++){
        cin>>x;
        h=x-d;
        if(h<0){
            p.pb({0,1});
            p.pb({x,-1});
            p.pb({2*l+h,1});
            p.pb({2*l,-1});
        }
        else{
            p.pb({h,1});
            p.pb({x,-1});
        }
   }
   p.pb({0,0});
   p.pb({2*l,0});
   sort(p.begin(),p.end());
   ll cnt=0;
   double prev=0;
   double res[100011]={0};
   for(int i=0;i<p.size();i++){
        if(i>0)
        res[cnt]+=p[i].f-prev;
        prev=p[i].f;
        cnt+=p[i].s;
   }
   for(int i=0;i<=n;i++){
    printf("%.10f\n",res[i]/(2.0*(double)l));
   }
}


#include<bits/stdc++.h>
using namespace std;
#define ll int
#define pi pair<double,ll>
#define pii pair<ll,pi>
#define mp make_pair
#define mod 1000000007
#define f first
#define s second
#define pb push_back
#define fr freopen("input-20.txt","r",stdin)
#define fo freopen("output-20.txt","w",stdout)
int main(){
   ll n,l,v1,v2;
   cin>>n>>l>>v1>>v2;
   double d=v1*l;
   d/=(double)(v1+v2);
   vector<pi>p;
   double x,h;
   for(int i=0;i<n;i++){
        cin>>x;
        h=x-d;
        if(h<0){
            p.pb({0,1});
            p.pb({x,-1});
            p.pb({2*l+h,1});
            p.pb({2*l,-1});
        }
        else{
            p.pb({h,1});
            p.pb({x,-1});
        }
   }
   sort(p.begin(),p.end());
   ll cnt=0;
   double prev=0;
   double res[100011]={0};
   for(int i=0;i<p.size();i++){
        res[cnt]+=p[i].f-prev;
        prev=p[i].f;
        cnt+=p[i].s;
   }
   for(int i=0;i<=n;i++){
    printf("%.10f ",res[i]/(2.0*l));
   }
}


#include <bits/stdc++.h>

using namespace std;

double a[200000], ans[200000];

int main()
{
    int n;
    double L, v1, v2;
    cin >> n >> L >> v1 >> v2;

    for (int i = 0; i < n; i++)
        cin >> a[i];
    double ml = (1 - v1 / (v1 + v2)) * L;
    vector <pair <double, int> > v;

    for (int i = 0; i < n; i++)
    {
        v.push_back(make_pair((2*L-a[i])/v1, i+1));

        if (a[i] < ml)
            v.push_back(mp((ml-a[i])/v1, -(i+1)));
        else
            v.push_back(mp((2*L-a[i]+ml)/v1, -(i+1)));
    }
    double T = 2*L/v1;

    v.push_back(mp(T, 0));
    sort(v.begin(), v.end());

    int cnt = 0;

    for (int i = 0; i < n; i++)
        if (0 <= a[i] && a[i] < ml)
            cnt++;
    double t = 0;

    for (int i = 0; i < v.size(); i++)
    {
        const int k = v[i].second;
        double nt = v[i].first;
        ans[cnt] += (nt-t) / T;
        t = nt;

        if (k > 0)
            cnt++;
        else if (k < 0)
            cnt--;
    }

    for (int i = 0; i <= n; i++)
        cout << ans[i] << '\n';
    return 0;
}


#include <bits/stdc++.h>

typedef long long int64;
#define sz(A) (int((A).size()))

using namespace std;

double a[200000], ans[200000];

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(NULL);

    int n;
    double L, v1, v2;
    cin >> n >> L >> v1 >> v2;

    for (int i = 0; i < n; i++)
        cin >> a[i];
    double ml = (1 - v1 / (v1 + v2)) * L;
    vector <pair <double, int> > v;

    for (int i = 0; i < n; i++)
    {
        v.push_back(make_pair((2 * L - a[i]) / v1, i + 1));

        if (a[i] < ml)
            v.push_back(make_pair((ml - a[i]) / v1, -(i + 1)));
        else
            v.push_back(make_pair((2 * L - a[i] + ml) / v1, -(i + 1)));
    }
    double T = 2 * L / v1;
    v.push_back(make_pair(T, 0));
    sort(v.begin(), v.end());
    int cnt = 0;

    for (int i = 0; i < n; i++)
        if (0 <= a[i] && a[i] < ml)
            cnt++;
    double t = 0;

    for (int i = 0; i < sz(v); i++)
    {
        const int k = v[i].second;
        double nt = v[i].first;
        ans[cnt] += (nt - t) / T;
        t = nt;

        if (k > 0)
            cnt++;
        else if (k < 0)
            cnt--;
    }
    cout.precision(20);

    for (int i = 0; i <= n; i++)
        cout << ans[i] << '\n';
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

double a[200000], ans[200000];

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(NULL);

    int n;
    double L, v1, v2;
    cin >> n >> L >> v1 >> v2;

    for (int i = 0; i < n; i++)
        cin >> a[i];
    double ml = (1 - v1 / (v1 + v2)) * L;
    vector <pair <double, int> > v;

    for (int i = 0; i < n; i++)
    {
        v.push_back(make_pair((2 * L - a[i]) / v1, i + 1));

        if (a[i] < ml)
            v.push_back(make_pair((ml - a[i]) / v1, -(i + 1)));
        else
            v.push_back(make_pair((2 * L - a[i] + ml) / v1, -(i + 1)));
    }
    double T = 2 * L / v1;
    v.push_back(make_pair(T, 0));
    sort(v.begin(), v.end());
    int cnt = 0;

    for (int i = 0; i < n; i++)
        if (0 <= a[i] && a[i] < ml)
            cnt++;
    double t = 0;

    for (int i = 0; i < v.size(); i++)
    {
        const int k = v[i].second;
        double nt = v[i].first;
        ans[cnt] += (nt - t) / T;
        t = nt;

        if (k > 0)
            cnt++;
        else if (k < 0)
            cnt--;
    }

    for (int i = 0; i <= n; i++)
        cout << ans[i] << '\n';
    return 0;
}


#include <bits/stdc++.h>

typedef long long int64;
#define sz(A) (int((A).size()))

using namespace std;

int check(int64 pos, vector <int64> cand, int64 d, int64 l)
{
    int res = upper_bound(cand.begin(), cand.end(), pos + d) - lower_bound(cand.begin(), cand.end(), pos);

    if (res < 0)
        res += l * 2;
    return res;
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);

    int n;
    int64 l, v1, v2;
    cin >> n >> l >> v1 >> v2;
    int64 d = v2 * l / (v1 + v2);
    vector <int64> A, cand;

    for (int i = 0; i < n; i++)
    {
        int64 x;
        cin >> x;
        A.push_back(x - d);
        A.push_back(x);
        cand.push_back(x);
    }
    A.push_back(0);
    A.push_back(l * 2);
    sort(A.begin(), A.end());
    A.resize(unique(A.begin(), A.end()) - A.begin());
    sort(cand.begin(), cand.end());
    vector <int> cnt(n + 1);

    for (int i = 0; i < sz(A) - 1; i++)
    {
        int64 pos = (A[i + 1] + A[i]) / 2;
        int64 len = max(0LL, A[i + 1] - A[i]);
        cnt[check(pos, cand, d, l)] += len;
        cout << A[i] << ' ' << A[i + 1] << ' ' << pos << ' ' << len << ' ' << check(pos, cand, d, l) << '\n';
    }
    int64 sum = 0;

    for (int i = 0; i <= n; i++)
        sum += cnt[i];
    cout.precision(20);

    for (int i = 0; i <= n; i++)
        cout << double(cnt[i]) / sum << '\n';
    cout << '\n';
    return 0;
}


#include <cstdio>
#include <algorithm>
using namespace std;

int n,l,v1,v2;
long long a[200005],ans[100005];

int main(){
    scanf("%d%d%d%d",&n,&l,&v1,&v2);
    for(int i=0;i<n;i++) scanf("%I64d",a+i);
    long long s=l*2ll*(v1+v2);
    for(int i=0;i<n;i++){
        a[i]*=v1+v2;
        a[i+n]=a[i]+s;
    }
    int i=0,j=0;
    long long x=0;
    while(a[j]<x+l*1ll*v2) j++;
    while(x<s){
        long long c=min(x+min(a[i]-x+1,a[j]-(x+l*1ll*v2)+1),s)-x;
        ans[j-i]+=c;
        x+=c;
        while(a[i]<x) i++;
        while(a[j]<x+l*1ll*v2) j++;
    }
    for(int i=0;i<=n;i++) printf("%.14f\n",ans[i]*1.0/s);
}


#include <cstdio>
#include <algorithm>
using namespace std;

int n,l,v1,v2;
long long a[200005],ans[100005];

long long gao(int i, int j, int x){
    return min(a[i]-x+1,a[j]-(x+l*1ll*v2)+1);
}

int main(){
    scanf("%d%d%d%d",&n,&l,&v1,&v2);
    for(int i=0;i<n;i++) scanf("%I64d",a+i);
    long long s=l*2ll*(v1+v2);
    for(int i=0;i<n;i++){
        a[i]*=v1+v2;
        a[i+n]=a[i]+s;
    }
    int i=0,j=0;
    long long x=0;
    while(a[j]<x+l*1ll*v2) j++;
    while(x<s){
        long long c=min(x+gao(i,j,x),s)-x;
        ans[j-i]+=c;
        x+=c;
        while(a[i]<x) i++;
        while(a[j]<x+l*1ll*v2) j++;
    }
    for(int i=0;i<=n;i++) printf("%.14f\n",ans[i]*1.0/s);
}


#include <cstdio>
#include <algorithm>
using namespace std;

int n,l,v1,v2;
long long a[200005],ans[100005];

long long gao(int i, int j, int x){
    return min(a[i]-x+1,a[j]-(x+l*1ll*v2)+1);
}

int main(){
    scanf("%d%d%d%d",&n,&l,&v1,&v2);
    for(int i=0;i<n;i++) scanf("%I64d",a+i);
    long long s=l*2ll*(v1+v2);
    for(int i=0;i<n;i++){
        a[i]*=v1+v2;
        a[i+n]=a[i]+s;
    }
    int i=0,j=0;
    long long x=0;
    while(a[j]<x+l*1ll*v2) j++;
    while(x<s){
        long long c=min(x+gao(i,j,x),s)-x;
        ans[j-i]+=c;
        x+=c;
        while(a[i]<x) i++;
        while(a[j]<x+l*1ll*v2) j++;
    }
    if(n==1000){
        for(int i=0;i<=n;i++) if(ans[i]) printf("ans[%d] = %I64d\n",i,ans[i]);
    }
    for(int i=0;i<=n;i++) printf("%.14f\n",ans[i]*1.0/s);
}


/*
 * File:      main.cpp
 * Author:    Hrayr [HarHro94]
 * Problem:
 * IDE:       Visual C++ 2012
 */
#pragma comment(linker, "/STACK:67108864")
#define _CRT_SECURE_NO_WARNINGS
#include <functional>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <fstream>
#include <cassert>
#include <iomanip>
#include <cstring>
#include <cstdio>
#include <string>
#include <vector>
#include <ctime>
#include <queue>
#include <stack>
#include <cmath>
#include <set>
#include <map>
using namespace std;

typedef long long LL;
typedef long double LD;
#define pb push_back
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define sz(v) (int)(v).size()

const int N = 100007;
vector<pair<LD, bool> > ev;
int n, L, v1, v2;
LD D, ans[N];

int main()
{
#ifdef harhro94
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif

    scanf("%d%d%d%d", &n, &L, &v1, &v2);
    D = (LD)L / (v1 + v2) * (LD)v2;
    int cur = 0;
    for (int i = 0; i < n; ++i)
    {
        int tmp;
        scanf("%d", &tmp);
        if (tmp > 0)
        {
            ev.pb(mp(2.0 * L - tmp, true));
            ++cur;
        }
        else
        {
            ev.pb(mp(tmp, true));
        }
        if (D < tmp - 1e-12)
        {
            ev.pb(mp(2 * L + D - tmp, false));
            --cur;
        }
        else
        {
            ev.pb(mp(D - tmp, false));
        }
    }
    sort(all(ev));
    LD prv = 0.0;
    for (int i = 0; i < sz(ev); ++i)
    {
        ans[cur] += (ev[i].first - prv);
        if (ev[i].second) // open
        {
            ++cur;
        }
        else // close
        {
            --cur;
        }
        assert(cur >= 0 && cur < N);
        prv = ev[i].first;
    }
    ans[cur] += (2 * L - prv);
    for (int i = 0; i <= n; ++i)
    {
        printf("%.12lf\n", (double)ans[i] / 2.0 / L);
    }

#ifdef harhro94
    cerr << fixed << setprecision(3) << "\nExecution time = " << clock() / 1000.0 << "s\n";
#endif
    return 0;
}


#include <bits/stdc++.h>

typedef long long ll;
using namespace std;

struct Counter
{
	static int k;
	Counter() {k++;}
	~Counter() {k--;}
};

int Counter::k = 0;

template<typename T>
void pr(const string& name, T t)
{
    cout << name << " = " << t << endl;
}

template<typename T, typename ... Types>
void pr(const string& names, T t, Types ... rest)
{
    auto comma_pos = names.find(',');
    cout << names.substr(0, comma_pos) << " = " << t << ", ";

    auto next_name_pos = names.find_first_not_of(" \t\n", comma_pos + 1);
    pr(string(names, next_name_pos), rest ...);
}

#define all(x) x.begin(), x.end()
#define f(i,a,b) for(int i = (a); i <= (b); i++)
#define fd(i,a,b) for(int i = (a); i >= (b); i--)
#define mp make_pair
#define faster_io() ios_base::sync_with_stdio(false)
#define pb push_back
#define pii pair<int,int>
#define SZ(x) ((int)x.size())
#define trace(...) pr(#__VA_ARGS__, __VA_ARGS__);
#define tracea(x) {string s = #x; Counter c##x; cout<<s.substr(0,1+s.find('['))<<Counter::k<<"]="<<x<<'\n';}
#define vii vector<pair<int,int>>

const ll MOD = 1000000007;

// ----------------------------------------------------------------------------------------------------------

double P[100005];
int N, L, V1, V2;
vector<int> A;

int get(double a, double b)
{
    auto it = lower_bound(all(A), a);
    auto jt = lower_bound(all(A), b);
    int idx_a = it - A.begin();
    int idx_b = jt - A.begin();
    return idx_b - idx_a;
}

int main()
{
    cin >> N >> L >> V1 >> V2;

    f(i,1,N)
    {
        int x;
        cin >> x;
        A.pb(x);
        A.pb(x+2*L);
    }

    sort(all(A));

    double speed = V1+V2;
    double length = L;
    double t = length / speed;
    double movement = t * (double) V2;

    vector<pair<double,int>> v;

    f(i,0,N)
    {
        double start = A[i] - movement;
        if(start < 0 || start >= 2*L) continue;
        double end = start + movement;
        int choc = get(start,end);
        v.pb({start,choc});
    }
    f(i,0,N)
    {
        double start = A[i];
        if(start < 0 || start >= 2*L) continue;
        double end = start + movement;
        int choc = get(start,end);
        v.pb({start,choc});
    }

    sort(all(v));

    f(i,1,SZ(v)-1) P[v[i].second] += (v[i].first - v[i-1].first) / (double) (2*L);
    P[v[0].second] += ((double) 2*L - v.back().first + v[0].first) / (double) (2*L);
    f(i,0,N) cout << setprecision(15) << fixed << P[i] << "\n";
}


#include <bits/stdc++.h>

typedef long long ll;
using namespace std;

struct Counter
{
	static int k;
	Counter() {k++;}
	~Counter() {k--;}
};

int Counter::k = 0;

template<typename T>
void pr(const string& name, T t)
{
    cout << name << " = " << t << endl;
}

template<typename T, typename ... Types>
void pr(const string& names, T t, Types ... rest)
{
    auto comma_pos = names.find(',');
    cout << names.substr(0, comma_pos) << " = " << t << ", ";

    auto next_name_pos = names.find_first_not_of(" \t\n", comma_pos + 1);
    pr(string(names, next_name_pos), rest ...);
}

#define all(x) x.begin(), x.end()
#define f(i,a,b) for(int i = (a); i <= (b); i++)
#define fd(i,a,b) for(int i = (a); i >= (b); i--)
#define mp make_pair
#define faster_io() ios_base::sync_with_stdio(false)
#define pb push_back
#define pii pair<int,int>
#define SZ(x) ((int)x.size())
#define trace(...) pr(#__VA_ARGS__, __VA_ARGS__);
#define tracea(x) {string s = #x; Counter c##x; cout<<s.substr(0,1+s.find('['))<<Counter::k<<"]="<<x<<'\n';}
#define vii vector<pair<int,int>>

const ll MOD = 1000000007;

// ----------------------------------------------------------------------------------------------------------

double P[100005];
int N, L, V1, V2;
vector<int> A;

int get(double a, double b)
{
    auto it = lower_bound(all(A), a);
    auto jt = lower_bound(all(A), b);
    int idx_a = it - A.begin();
    int idx_b = jt - A.begin();
    return idx_b - idx_a;
}

int main()
{
    cin >> N >> L >> V1 >> V2;
    f(i,1,N)
    {
        int x;
        cin >> x;
        A.pb(x);
        A.pb(x+2*L);
    }

    sort(all(A));

    double speed = V1+V2;
    double length = L;
    double t = length / speed;
    double movement = t * (double) V2;

    vector<pair<double,int>> v;

    f(i,0,N)
    {
        double start = A[i] - movement;
        if(start < 0 || start >= 2*L) continue;
        double end = start + movement;
        int choc = get(start,end);
        v.pb({start,choc});
    }
    f(i,0,N)
    {
        double start = A[i];
        if(start < 0 || start >= 2*L) continue;
        double end = start + movement;
        int choc = get(start,end);
        v.pb({start,choc});
    }

    sort(all(v));

    f(i,1,SZ(v)-1) P[v[i].second] += (v[i].first - v[i-1].first) / (double) (2*L);
    P[v[0].second] += ((double) 2*L - v.back().first) / (double) (2*L);
    f(i,0,N) cout << setprecision(15) << fixed << P[i] << "\n";
}


#include <bits/stdc++.h>

typedef long long ll;
using namespace std;

struct Counter
{
	static ll k;
	Counter() {k++;}
	~Counter() {k--;}
};

ll Counter::k = 0;

template<typename T>
void pr(const string& name, T t)
{
    cout << name << " = " << t << endl;
}

template<typename T, typename ... Types>
void pr(const string& names, T t, Types ... rest)
{
    auto comma_pos = names.find(',');
    cout << names.substr(0, comma_pos) << " = " << t << ", ";

    auto next_name_pos = names.find_first_not_of(" \t\n", comma_pos + 1);
    pr(string(names, next_name_pos), rest ...);
}

#define all(x) x.begin(), x.end()
#define f(i,a,b) for(ll i = (a); i <= (b); i++)
#define fd(i,a,b) for(ll i = (a); i >= (b); i--)
#define mp make_pair
#define faster_io() ios_base::sync_with_stdio(false)
#define pb push_back
#define pii pair<ll,ll>
#define SZ(x) ((ll)x.size())
#define trace(...) pr(#__VA_ARGS__, __VA_ARGS__);
#define tracea(x) {string s = #x; Counter c##x; cout<<s.substr(0,1+s.find('['))<<Counter::k<<"]="<<x<<'\n';}
#define vii vector<pair<ll,ll>>

const ll MOD = 1000000007;

// ----------------------------------------------------------------------------------------------------------

double P[100005];
ll N, L, V1, V2;
vector<ll> A;

ll get(double a, double b)
{
    auto it = lower_bound(all(A), a);
    auto jt = lower_bound(all(A), b);
    ll idx_a = it - A.begin();
    ll idx_b = jt - A.begin();
    return idx_b - idx_a;
}

int main()
{
    cin >> N >> L >> V1 >> V2;

    f(i,1,N)
    {
        ll x;
        cin >> x;
        A.pb(x);
        A.pb(x+2*L);
    }

    sort(all(A));

    double speed = V1+V2;
    double length = L;
    double t = length / speed;
    double movement = t * (double) V2;

    vector<pair<double,ll>> v;

    f(i,0,2*N)
    {
        double start = A[i] - movement;
        if(start <= 0 || start >= 2*L) continue;
        double end = start + movement;
        ll choc = get(start,end);
        v.pb({start,choc});
    }
    f(i,0,2*N)
    {
        double start = A[i];
        if(start <= 0 || start >= 2*L) continue;
        double end = start + movement;
        ll choc = get(start,end);
        v.pb({start,choc});
    }

    ll choc = get(0,movement);
    v.pb({0,choc});
    v.pb({2*L,choc});

    sort(all(v));

    f(i,1,SZ(v)-1) P[v[i].second] += (v[i].first - v[i-1].first) / (double) (2*L);
    P[v[0].second] += ((double) 2*L - v.back().first + v[0].first) / (double) (2*L);
    f(i,0,N) cout << setprecision(15) << fixed << P[i] << "\n";
}


#include <bits/stdc++.h>

typedef long long ll;
using namespace std;

struct Counter
{
	static int k;
	Counter() {k++;}
	~Counter() {k--;}
};

int Counter::k = 0;

template<typename T>
void pr(const string& name, T t)
{
    cout << name << " = " << t << endl;
}

template<typename T, typename ... Types>
void pr(const string& names, T t, Types ... rest)
{
    auto comma_pos = names.find(',');
    cout << names.substr(0, comma_pos) << " = " << t << ", ";

    auto next_name_pos = names.find_first_not_of(" \t\n", comma_pos + 1);
    pr(string(names, next_name_pos), rest ...);
}

#define all(x) x.begin(), x.end()
#define f(i,a,b) for(int i = (a); i <= (b); i++)
#define fd(i,a,b) for(int i = (a); i >= (b); i--)
#define mp make_pair
#define faster_io() ios_base::sync_with_stdio(false)
#define pb push_back
#define pii pair<int,int>
#define SZ(x) ((int)x.size())
#define trace(...) pr(#__VA_ARGS__, __VA_ARGS__);
#define tracea(x) {string s = #x; Counter c##x; cout<<s.substr(0,1+s.find('['))<<Counter::k<<"]="<<x<<'\n';}
#define vii vector<pair<int,int>>

const ll MOD = 1000000007;

// ----------------------------------------------------------------------------------------------------------

double P[100005];
int N, L, V1, V2;
vector<int> A;

int get(double a, double b)
{
    auto it = lower_bound(all(A), a);
    auto jt = lower_bound(all(A), b);
    int idx_a = it - A.begin();
    int idx_b = jt - A.begin();
    return idx_b - idx_a;
}

int main()
{
    cin >> N >> L >> V1 >> V2;

    f(i,1,N)
    {
        int x;
        cin >> x;
        A.pb(x);
        A.pb(x+2*L);
    }

    sort(all(A));

    double speed = V1+V2;
    double length = L;
    double t = length / speed;
    double movement = t * (double) V2;

    vector<pair<double,int>> v;

    f(i,0,2*N)
    {
        double start = A[i] - movement;
        if(start <= 0 || start >= 2*L) continue;
        double end = start + movement;
        int choc = get(start,end);
        v.pb({start,choc});
    }
    f(i,0,2*N)
    {
        double start = A[i];
        if(start <= 0 || start >= 2*L) continue;
        double end = start + movement;
        int choc = get(start,end);
        v.pb({start,choc});
    }

    int choc = get(0,movement);
    v.pb({0,choc});
    v.pb({2*L,choc});

    sort(all(v));

    f(i,1,SZ(v)-1) P[v[i].second] += (v[i].first - v[i-1].first) / (double) (2*L);
    P[v[0].second] += ((double) 2*L - v.back().first + v[0].first) / (double) (2*L);
    f(i,0,N) cout << setprecision(15) << fixed << P[i] << "\n";
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <iomanip>
#include <cstring>
#include <sstream>
#include <vector>
#include <map>
#include <set>
#include <functional>
#include <numeric>
#include <utility>

using namespace std;

#define Rep(i,n) for(int i = 0; i < n; ++i)
#define Rep2(i, f, t) for(int i = (f); i <= (t); ++i)
#define tr(C,it) for(__typeof__((C).begin()) it = (C).begin(); it != (C).end(); ++it)

typedef long long ll;
const int maxn = 100000 + 10;
const double eps = 1e-11;
int v1, v2;
int L;
int n;
ll pos[maxn + maxn];
double prob[maxn];
ll avaLen;

int main() {
	scanf("%d%d%d%d", &n, &L, &v1, &v2);
	int tt;
	Rep(i, n) {
		scanf("%d", &tt);
		pos[i] = (ll)tt * (v1 + v2);
		pos[i + n] = pos[i] + (ll)(L + L) * (v1 + v2);
	}
	avaLen = (ll)v2 * L;
	fill(prob, prob + n + 1, 0.0);
	ll cur = 0;
	int cnt = 0;
	int leftPos, rightPos;
	leftPos = rightPos = 0;
	ll maxL = (ll)(L + L) * (v1 + v2);
	while(pos[rightPos] < cur + avaLen) {
		++rightPos;
		++cnt;
	}
	ll v[3];
	ll minv;
	while(cur < maxL) {
		v[0] = maxL - cur;
		v[1] = pos[rightPos] - cur - avaLen;
		if(v[1] < 0) v[1] = maxL;
		v[2] = pos[leftPos] - cur;
		minv = min(v[0], min(v[1], v[2]));
		//cout<<"Check "<<minv<<' '<<leftPos<<' '<<rightPos<<endl;
		prob[cnt] += (double)minv / maxL;
		if(v[0] == minv) {
			//;;;;
		} else if(v[1] == minv) {
			++rightPos;
			++cnt;
		} else {
			//v[2] == minv
			++leftPos;
			--cnt;
		}
		cur += minv;
	}
	Rep(i, n + 1) {
		printf("%.20f\n", prob[i]);
	}
	return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <iomanip>
#include <cstring>
#include <sstream>
#include <vector>
#include <map>
#include <set>
#include <functional>
#include <numeric>
#include <utility>

using namespace std;

#define Rep(i,n) for(int i = 0; i < n; ++i)
#define Rep2(i, f, t) for(int i = (f); i <= (t); ++i)
#define tr(C,it) for(__typeof__((C).begin()) it = (C).begin(); it != (C).end(); ++it)

const int maxn = 100000 + 10;
const double eps = 1e-11;
int v1, v2;
int L;
int n;
unsigned int pos[maxn + maxn];
double prob[maxn];
double avaLen;

int main() {
	scanf("%d%d%d%d", &n, &L, &v1, &v2);
	Rep(i, n) {
		scanf("%d", pos + i);
		pos[i + n] = pos[i] + L + L;
	}
	avaLen = v2 * ((double)L / (v1 + v2));
	fill(prob, prob + n + 1, 0.0);
	double cur = 0.0;
	int posRight = 0;
	int posLeft = 0;
	int curCnt = 0;
	while(posRight < n && (double)pos[posRight] < avaLen + cur + eps) {
		++posRight;
		++curCnt;
	}

	//cout<<"See "<<posRight<<endl;
	while(cur < 2.0 * L - eps) {
		double minDelta = 2.0 * L - cur;
		minDelta = min(minDelta, (double)pos[posLeft] - cur + eps);
		if(posRight < n + n && pos[posRight] > cur + avaLen) {
			minDelta = min(minDelta, (double)pos[posRight] - avaLen - cur + eps);
		}

		prob[curCnt] += minDelta / (2.0 * L);
		//cout<<"SEEE "<<prob[0]<<' '<<prob[1]<<endl;

		cur += minDelta;
		//cout<<"Check "<<cur<<' '<<minDelta<<' '<<posLeft<<' '<<posRight<<endl;
		//cout<<"ASDASD "<<(double)pos[posRight]<<' '<<avaLen + cur + eps<<endl;
		while(posRight < n + n && (double)pos[posRight] < avaLen + cur + eps) {
			++posRight;
			++curCnt;
		}

		while((double)pos[posLeft] < cur) {
			++posLeft;
			--curCnt;
		}
		//cout<<"Check2 "<<cur<<' '<<minDelta<<' '<<posLeft<<' '<<posRight<<endl;

	}
	Rep(i, n + 1) {
		printf("%.20f\n", prob[i]);
	}
	return 0;
}


#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cassert>
#include <ctime>
#include <cstring>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <deque>
#include <list>
#include <stack>
#include <bitset>
#include <algorithm>
#include <iomanip>

using namespace std;

#define forn(i,n) for (int i = 0; i < int(n); i++)
#define ford(i,n) for (int i = int(n) - 1; i >= 0; i--)
#define fore(i,l,r) for (int i = int(l); i <= int(r); i++)
#define all(a) a.begin(), a.end()
#define sz(a) int(a.size())
#define mp make_pair
#define pb push_back
#define ft first
#define sc second
#define x first
#define y second

template<typename X> inline X abs(const X& a) { return a < 0 ? -a : a; }
template<typename X> inline X sqr(const X& a) { return a * a; }

typedef long long li;
typedef long double ld;
typedef pair<int, int> pt;

const int INF = int(1e9);
const li INF64 = li(1e18);
const ld EPS = 1e-9;
const ld PI = acosl(ld(-1));

const int N = 100 * 1000 + 13;
int n, l, v1, v2;
int a[N];

inline bool read()
{
    if (scanf ("%d%d%d%d", &n, &l, &v1, &v2) != 4)
        return false;

    forn (i, n)
        assert(scanf ("%d", &a[i]) == 1);

    return true;
}

int sze = 0;
pair<ld, int> e[2 * N];

inline bool cmp (const pair<ld, int>& a, const pair<ld, int>& b)
{
    if (abs(a.ft - b.ft) < EPS)
        return a.sc < b.sc;

    return a.ft < b.ft;
}

ld ans[N];

inline void solve()
{
    ld len = (ld(l) * ld(v2) / (ld(v1) + ld(v2)));

    forn (i, n)
    {
        e[sze++] = mp(a[i], -1);

        ld st = a[i] - len;
        while (st < 0)
            st += 2 * l;

        e[sze++] = mp(st, +1);
    }

    e[sze++] = mp(2 * l, 0);

    sort(e, e + sze, cmp);

    int b = 0;
    forn (i, n)
        if (ld(a[i]) < len - EPS)
            b++;

    ld x = 0;

    forn (i, sze)
    {
        ld nx = e[i].ft;
        int nb = b + e[i].sc;

        ans[b] += nx - x;

        x = nx;
        b = nb;
    }

    ld ll = 0;
    forn (i, n + 1)
        ll += ans[i];

    assert(abs(ll - ld(2) * l) < EPS);

    forn (i, n + 1)
        ans[i] /= ld(2 * l);

    forn (i, n + 1)
        printf ("%.15f\n", double(ans[i]));
}

int main()
{
#ifdef SU2_PROJ
    assert(freopen("input.txt", "r", stdin));
    assert(freopen("output.txt", "w", stdout));
#endif

    cout << setprecision(25) << fixed;
    cerr << setprecision(10) << fixed;

    srand(int(time(NULL)));

    assert(read());
    solve();

#ifdef SU2_PROJ
    cerr << "TIME: " << clock() << endl;
#endif

    return 0;
}


import java.util.List;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.util.Collections;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author AlexFetisov
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    double timeNeed;

    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int n = in.nextInt();
        double len = in.nextInt();
        double v1 = in.nextInt();
        double v2 = in.nextInt();

        int[] a = Utils.readIntArray(in, n);

        timeNeed = len / (v1 + v2);
        double X = timeNeed * v2;

        List<Event> events = new ArrayList<Event>();
        for (int i = 0; i < n; ++i) {
            double x = a[i];
            if (DoubleUtils.compareTo(x, X) < 0) {
                events.add(new Event(0, true));
                events.add(new Event((X - x) / v1, false));

                events.add(new Event((2 * len - x) / v1, true));
                events.add(new Event((2 * len - x + X) / v1, false));
            } else {
                if (DoubleUtils.compareTo(x, len) < 0) {
                    events.add(new Event((len * 2 - x) / v1, true));
                    events.add(new Event((len * 2 - x + X) / v1, false));
                } else {
                    events.add(new Event((len * 2 - x) / v1, true));
                    events.add(new Event((len * 2 - x + X) / v1, false));
                }
            }
        }
        timeNeed = 2. * len / v1;
        events.add(new Event(timeNeed, false));
        Collections.sort(events);
        double[] sum = new double[n+1];
        double prev = 0;
        int cur = 0;
        for (Event e : events) {
            if (DoubleUtils.compareTo(e.time, timeNeed) > 0) {
                break;
            }
            if (DoubleUtils.compareTo(e.time, prev) != 0) {
                sum[cur] += (e.time - prev);
                prev = e.time;
            }

            if (e.enter) {
                ++cur;
            } else {
                --cur;
            }
        }
        for (int i = 0; i <= n; ++i) {
            out.println(sum[i] / timeNeed);
        }

    }

    class Event implements Comparable<Event> {
        double time;
        boolean enter;

        public Event(double time, boolean enter) {
            this.time = time;
            this.enter = enter;
        }

        public int compareTo(Event o) {
            if (DoubleUtils.compareTo(time, o.time) != 0) {
                return DoubleUtils.compareTo(time, o.time);
            }
            return Boolean.compare(o.enter, enter);
//            if (o.enter == enter) return 0;
//            return enter == false ? -1 : 1;
        }
    }
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer stt;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
    }

    public String nextLine() {
        try {
            return reader.readLine();
        } catch (IOException e) {
            return null;
        }
    }

    public String nextString() {
        while (stt == null || !stt.hasMoreTokens()) {
            stt = new StringTokenizer(nextLine());
        }
        return stt.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(nextString());
    }

}

class Utils {
    public static int[] readIntArray(InputReader in, int n) {
        int[] a = new int[n];
        for (int i = 0; i < n; ++i) {
            a[i] = in.nextInt();
        }
        return a;
    }

}

class DoubleUtils {
    public static final double EPS = 1e-12;

    public static int compareTo(double a, double b) {
        if (doubleEqual(a, b)) {
            return 0;
        }
        if (a < b) {
            return -1;
        }
        return 1;
    }

    private static boolean doubleEqual(double a, double b) {
        return Math.abs(a - b) < EPS;
    }

}


import java.util.List;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.ArrayList;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.util.Collections;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author AlexFetisov
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    double timeNeed;

    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int n = in.nextInt();
        double len = in.nextInt();
        double v1 = in.nextInt();
        double v2 = in.nextInt();

        int[] a = Utils.readIntArray(in, n);

        timeNeed = len / (v1 + v2);
        double X = timeNeed * v2;

        List<Event> events = new ArrayList<Event>();
        for (int i = 0; i < n; ++i) {
            double x = a[i];
            if (DoubleUtils.compareTo(x, X) < 0) {
                events.add(new Event(0, true));
                events.add(new Event((X - x) / v1, false));

                events.add(new Event((2 * len - x) / v1, true));
                events.add(new Event((2 * len - x + X) / v1, false));
            } else {
                if (DoubleUtils.compareTo(x, len) < 0) {
                    events.add(new Event((len * 2 - x) / v1, true));
                    events.add(new Event((len * 2 - x + X) / v1, false));
                } else {
                    events.add(new Event((len * 2 - x) / v1, true));
                    events.add(new Event((len * 2 - x + X) / v1, false));
                }
            }
        }
        timeNeed = 2. * len / v1;
        events.add(new Event(timeNeed, false, true));
        Collections.sort(events);
        double[] sum = new double[n+1];
        double prev = 0;
        int cur = 0;
        for (Event e : events) {
            if (DoubleUtils.compareTo(e.time, prev) != 0) {
                sum[cur] += (e.time - prev);
                prev = e.time;
            }
            if (e.end) {
                break;
            }
            if (e.enter) {
                ++cur;
            } else {
                --cur;
            }
        }
        for (int i = 0; i <= n; ++i) {
            out.println(sum[i] / timeNeed);
        }

    }

    class Event implements Comparable<Event> {
        double time;
        boolean enter;
        boolean end;

        public Event(double time, boolean enter) {
            this.time = time;
            this.enter = enter;
            this.end = false;
        }

        public Event(double time, boolean enter, boolean end) {
            this.time = time;
            this.enter = enter;
            this.end = end;
        }

        public int compareTo(Event o) {
            if (time != o.time) {
                return DoubleUtils.compareTo(time, o.time);
            }
            if (end != o.end) {
                return end ? 1 : -1;
            }
            if (o.enter == enter) return 0;
            return enter == false ? -1 : 1;
        }
    }
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer stt;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
    }

    public String nextLine() {
        try {
            return reader.readLine();
        } catch (IOException e) {
            return null;
        }
    }

    public String nextString() {
        while (stt == null || !stt.hasMoreTokens()) {
            stt = new StringTokenizer(nextLine());
        }
        return stt.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(nextString());
    }

}

class Utils {
    public static int[] readIntArray(InputReader in, int n) {
        int[] a = new int[n];
        for (int i = 0; i < n; ++i) {
            a[i] = in.nextInt();
        }
        return a;
    }

}

class DoubleUtils {
    public static final double EPS = 1e-8;

    public static int compareTo(double a, double b) {
        if (doubleEqual(a, b)) {
            return 0;
        }
        if (a < b) {
            return -1;
        }
        return 1;
    }

    private static boolean doubleEqual(double a, double b) {
        return Math.abs(a - b) < EPS;
    }

}


import java.util.List;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.ArrayList;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.util.Collections;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author AlexFetisov
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    double timeNeed;

    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int n = in.nextInt();
        double len = in.nextInt();
        double v1 = in.nextInt();
        double v2 = in.nextInt();

        int[] a = Utils.readIntArray(in, n);

        timeNeed = len / (v1 + v2);
        double X = timeNeed * v2;

        List<Event> events = new ArrayList<Event>();
        for (int i = 0; i < n; ++i) {
            double x = a[i];
            if (DoubleUtils.compareTo(x, X) < 0) {
                events.add(new Event(0, true));
                events.add(new Event((X - x) / v1, false));

                events.add(new Event((2 * len - x) / v1, true));
                events.add(new Event((2 * len - x + X) / v1, false));
            } else {
                if (DoubleUtils.compareTo(x, len) < 0) {
                    events.add(new Event((len * 2 - x) / v1, true));
                    events.add(new Event((len * 2 - x + X) / v1, false));
                } else {
                    events.add(new Event((len * 2 - x) / v1, true));
                    events.add(new Event((len * 2 - x + X) / v1, false));
                }
            }
        }
        timeNeed = 2. * len / v1;
        events.add(new Event(timeNeed, false));
        Collections.sort(events);
        double[] sum = new double[n+1];
        double prev = 0;
        int cur = 0;
        for (Event e : events) {
            if (DoubleUtils.compareTo(e.time, timeNeed) > 0) {
                break;
            }
            if (DoubleUtils.compareTo(e.time, prev) != 0) {
                sum[cur] += (e.time - prev);
                prev = e.time;
            }

            if (e.enter) {
                ++cur;
            } else {
                --cur;
            }
        }
        for (int i = 0; i <= n; ++i) {
            out.println(sum[i] / timeNeed);
        }

    }

    class Event implements Comparable<Event> {
        double time;
        boolean enter;

        public Event(double time, boolean enter) {
            this.time = time;
            this.enter = enter;
        }

        public int compareTo(Event o) {
            if (time != o.time) {
                return DoubleUtils.compareTo(time, o.time);
            }
            if (o.enter == enter) return 0;
            return enter == false ? -1 : 1;
        }
    }
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer stt;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
    }

    public String nextLine() {
        try {
            return reader.readLine();
        } catch (IOException e) {
            return null;
        }
    }

    public String nextString() {
        while (stt == null || !stt.hasMoreTokens()) {
            stt = new StringTokenizer(nextLine());
        }
        return stt.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(nextString());
    }

}

class Utils {
    public static int[] readIntArray(InputReader in, int n) {
        int[] a = new int[n];
        for (int i = 0; i < n; ++i) {
            a[i] = in.nextInt();
        }
        return a;
    }

}

class DoubleUtils {
    public static final double EPS = 1e-8;

    public static int compareTo(double a, double b) {
        if (doubleEqual(a, b)) {
            return 0;
        }
        if (a < b) {
            return -1;
        }
        return 1;
    }

    private static boolean doubleEqual(double a, double b) {
        return Math.abs(a - b) < EPS;
    }

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;

import javax.naming.InitialContext;

public class C
{
    public static void main(String [] args) throws IOException
    {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter writer = new PrintWriter(System.out);

        StringTokenizer tokenizer = new StringTokenizer(reader.readLine());
        int n = Integer.parseInt(tokenizer.nextToken());
        int l = Integer.parseInt(tokenizer.nextToken());
        int v1 = Integer.parseInt(tokenizer.nextToken());
        int v2 = Integer.parseInt(tokenizer.nextToken());

        int [] pos = new int[3*n];
        tokenizer = new StringTokenizer(reader.readLine());
        for(int i = 0 ; i < n ; i++)
            pos[i] = Integer.parseInt(tokenizer.nextToken());
        for(int i = n ; i < 2*n ; i++)
        {
            pos[i] = pos[i-n] + 2*l;
            pos[i+n] = pos[i] + 2*l;
        }

        double d = 1L*v2*l/(double)(v1+v2);
        double [] res = new double[n+1];

        for(int st = 0 ; st < n ;)
        {
            int ub = 3*n-1;
            int lb = st;

            while(ub - lb > 1)
            {
                int mid = lb + ub >> 1;
                if(pos[mid] - pos[st] > d)
                    ub = mid;
                else
                    lb = mid;
            }

            int en = lb;

            int get = en - st;

            int nSt = st+1;
            int nEn = en+1;

            while(true)
            {
                if(pos[nEn] - pos[nSt] > d)
                    break;

                if(nEn == en+1)
                    res[get] += (pos[nEn] - d - pos[st])/(double)(2*l);
                else
                    res[get] += (pos[nEn] - pos[nEn-1])/(double)(2*l);
                get++;
                //res[get] += d/(double)2*l;
                nEn++;
            }

            nEn--;

            res[get] += (pos[nSt] - (pos[nEn] - d))/(double)(2*l);

            st = nSt;
        }

        for(int i = 0 ; i <= n ; i++)
            writer.println(res[i]);
        writer.flush();
        writer.close();
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;

import javax.naming.InitialContext;

public class C
{
    public static void main(String [] args) throws IOException
    {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter writer = new PrintWriter(System.out);

        StringTokenizer tokenizer = new StringTokenizer(reader.readLine());
        int n = Integer.parseInt(tokenizer.nextToken());
        int l = Integer.parseInt(tokenizer.nextToken());
        int v1 = Integer.parseInt(tokenizer.nextToken());
        int v2 = Integer.parseInt(tokenizer.nextToken());

        int [] pos = new int[3*n];
        tokenizer = new StringTokenizer(reader.readLine());
        for(int i = 0 ; i < n ; i++)
            pos[i] = Integer.parseInt(tokenizer.nextToken());
        for(int i = n ; i < 2*n ; i++)
        {
            pos[i] = pos[i-n] + 2*l;
            pos[i+n] = pos[i] + 2*l;
        }

        double d = 1L*v2*l/(double)(v1+v2);
        double [] res = new double[n+1];

        for(int st = 0 ; st < n ;)
        {
            int ub = 3*n-1;
            int lb = st;

            while(ub - lb > 1)
            {
                int mid = lb + ub >> 1;
                if(pos[mid] - pos[st] > d)
                    ub = mid;
                else
                    lb = mid;
            }

            int en = lb;

            int get = en - st;

            int nSt = st+1;
            int nEn = en+1;

            while(true)
            {
                if(pos[nEn] - pos[nSt] > d)
                    break;

                if(nEn == en+1)
                    res[get] += (pos[nEn] - d - pos[st])/(double)(2*l);
                else
                    res[get] += (pos[nEn] - pos[nEn-1])/(double)(2*l);
                get++;
                nEn++;
            }

            nEn--;

            if(nEn == en)
                res[get] += (pos[nSt] - pos[st])/(double)(2*l);
            else
                res[get] += (pos[nSt] - (pos[nEn] - d))/(double)(2*l);

            st = nSt;
        }

        for(int i = 0 ; i <= n ; i++)
            writer.println(res[i]);
        writer.flush();
        writer.close();
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;

public class C
{
    public static void main(String [] args) throws IOException
    {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter writer = new PrintWriter(System.out);

        StringTokenizer tokenizer = new StringTokenizer(reader.readLine());
        int n = Integer.parseInt(tokenizer.nextToken());
        int l = Integer.parseInt(tokenizer.nextToken());
        int v1 = Integer.parseInt(tokenizer.nextToken());
        int v2 = Integer.parseInt(tokenizer.nextToken());

        long [] pos = new long[3*n];
        tokenizer = new StringTokenizer(reader.readLine());
        for(int i = 0 ; i < n ; i++)
            pos[i] = Integer.parseInt(tokenizer.nextToken());
        for(int i = n ; i < 2*n ; i++)
        {
            pos[i] = pos[i-n] + 2L*l;
            pos[i+n] = pos[i] + 2L*l;
        }

        double d = 1L*v2*l/(double)(v1+v2);
        double [] res = new double[n+1];

        for(int st = 0 ; st < n ;)
        {
            int ub = 3*n-1;
            int lb = st;

            while(ub - lb > 1)
            {
                int mid = lb + ub >> 1;
                if(pos[mid] - pos[st] > d)
                    ub = mid;
                else
                    lb = mid;
            }

            int en = lb;

            int get = en - st;

            int nSt = st+1;
            int nEn = en+1;

            while(true)
            {
                if(pos[nEn] - pos[nSt] > d)
                    break;

                if(nEn == en+1)
                    res[get] += (pos[nEn] - d - pos[st])/(double)(2*l);
                else
                    res[get] += (pos[nEn] - pos[nEn-1])/(double)(2*l);
                get++;
                nEn++;
            }

            nEn--;

            if(nEn == en)
                res[get] += (pos[nSt] - pos[st])/(double)(2*l);
            else
                res[get] += (pos[nSt] - (pos[nEn] - d))/(double)(2*l);

            st = nSt;
        }

        for(int i = 0 ; i <= n ; i++)
            writer.println(res[i]);
        writer.flush();
        writer.close();
    }
}


import java.io.*;
import java.util.*;

public class CF {
	void solve() {
		int n = in.nextInt();
		int l = in.nextInt();
		int v1 = in.nextInt();
		int v2 = in.nextInt();
		final long up = l * 1L * v2;
		final long down = v1 + v2;
		f = up / (down + 0.);
		int[] pos = new int[n];
		for (int i = 0; i < n; i++) {
			pos[i] = in.nextInt();
		}
		ArrayList<Event> allEvents = new ArrayList<>();
		for (int i = 0; i < n; i++) {
			for (int add = 0; add < 2; add++) {
				allEvents.add(new Event(pos[i] + add * 2L * l, true));
				allEvents.add(new Event(pos[i] + add * 2L * l, false));
			}
		}
		Collections.sort(allEvents, new Comparator<Event>() {

			@Override
			public int compare(Event o1, Event o2) {
				if (o1.add == o2.add) {
					return Long.compare(o1.pos, o2.pos);
				}
				if (!o1.add && o2.add) {
					return -compare(o2, o1);
				}
				// -1 if o1.pos - up / down < o2.pos
				long xx = (o1.pos - o2.pos) * down - up;
				return xx < 0 ? -1 : 1;
			}
		});
		double curTime = 0;
		int curCnt = 0;
		double[] ans = new double[n + 1];
		for (Event e : allEvents) {
			double diff = Math.max(0, Math.min(e.realTime, 2.0 * l) - curTime);
			ans[curCnt] += diff / (2.0 * l);
			curCnt += e.add ? 1 : -1;
			curTime = Math.max(curTime, e.realTime);
		}
		for (double z : ans) {
			out.println(z);
		}
	}

	double f;

	class Event {
		long pos;
		boolean add;
		double realTime;

		public Event(long pos, boolean add) {
			super();
			this.pos = pos;
			this.add = add;
			realTime = add ? pos - f : pos;
		}

		@Override
		public String toString() {
			return "Event [pos=" + pos + ", add=" + add + ", realTime="
					+ realTime + "]";
		}

	}

	private class InputReader {
		StringTokenizer st;
		BufferedReader br;

		public InputReader(File f) {
			try {
				br = new BufferedReader(new FileReader(f));
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}

		public InputReader(InputStream f) {
			br = new BufferedReader(new InputStreamReader(f));
		}

		String next() {
			while (st == null || !st.hasMoreElements()) {
				String s;
				try {
					s = br.readLine();
				} catch (IOException e) {
					return null;
				}
				if (s == null)
					return null;
				st = new StringTokenizer(s);
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}

		boolean hasMoreElements() {
			while (st == null || !st.hasMoreElements()) {
				String s;
				try {
					s = br.readLine();
				} catch (IOException e) {
					return false;
				}
				st = new StringTokenizer(s);
			}
			return st.hasMoreElements();
		}

		long nextLong() {
			return Long.parseLong(next());
		}
	}

	InputReader in;
	PrintWriter out;

	void solveIO() throws IOException {
		in = new InputReader(System.in);
		out = new PrintWriter(System.out);

		solve();

		out.close();

	}

	public static void main(String[] args) throws IOException {
		new CF().solveIO();
	}
}


import java.util.*;
import java.io.*;

public class C {
	FastScanner in;
	PrintWriter out;

	class Event implements Comparable<Event> {
		int type;
		double val;

		public Event(int type, double val) {
			this.type = type;
			this.val = val;
		}

		@Override
		public int compareTo(Event o) {
			if (val != o.val) {
				return Double.compare(val, o.val);
			}
			return Integer.compare(type, o.type);
		}
	}

	public void solve() throws IOException {
		int n = in.nextInt();
		double l  = in.nextDouble();
		double vLine = in.nextDouble();
		double vAnton = in.nextDouble();
		double[] prob = new double[n + 1];
		double[] a = new double[n];
		double time = l / (vLine + vAnton);
		Event[] events = new Event[2 * n];
		for (int i = 0; i < n; i++) {
			a[i] = in.nextDouble();
			Event open = new Event(0, a[i] - vAnton * time);
			Event close = new Event(1, a[i]);
			events[2 * i] = open;
			events[2 * i + 1] = close;
		}
		Arrays.sort(events);
		int cnt = 0;
		double prev = 0;
		for (Event e : events) {
			if (e.type == 0)
				cnt++;
			if (e.type == 1)
				cnt--;
			prev = e.val;
		}
		for (Event e : events) {
			double val = e.val - prev;
			if (val < 0) {
				val += 2 * l;
			}
			prob[cnt] += val / (2 * l);
			if (e.type == 0)
				cnt++;
			if (e.type == 1)
				cnt--;
			prev = e.val;
		}
		for (int i = 0; i <= n; i++) {
			out.println(prob[i]);
		}

	}

	public void run() {
		try {
			in = new FastScanner();
			out = new PrintWriter(System.out);

			solve();

			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}
	}

	public static void main(String[] arg) {
		new C().run();
	}
}


import java.util.*;
import java.io.*;

public class C {
	FastScanner in;
	PrintWriter out;

	class Event implements Comparable<Event> {
		int type;
		long val;

		public Event(int type, long val) {
			this.type = type;
			this.val = val;
		}

		@Override
		public int compareTo(Event o) {
			if (val != o.val) {
				return Long.compare(val, o.val);
			}
			return Integer.compare(type, o.type);
		}
	}

	public void solve() throws IOException {
		int n = in.nextInt();
		long l  = in.nextLong();
		long vLine = in.nextLong();
		long vAnton = in.nextLong();
		double[] prob = new double[n + 1];
		long[] a = new long[n];
		long time = l;
		Event[] events = new Event[2 * n];
		for (int i = 0; i < n; i++) {
			a[i] = in.nextLong() * (vLine + vAnton);
			Event open = new Event(0, a[i] - vAnton * time);
			Event close = new Event(1, a[i]);
			events[2 * i] = open;
			events[2 * i + 1] = close;
		}
		Arrays.sort(events);
		int cnt = 0;
		long prev = 0;
		for (Event e : events) {
			if (e.type == 0)
				cnt++;
			if (e.type == 1)
				cnt--;
			prev = e.val;
		}
		for (Event e : events) {
			long val = e.val - prev;
			if (val < 0) {
				val += 2 * l * (vLine + vAnton);
			}
			prob[cnt] += val;
			if (e.type == 0)
				cnt++;
			if (e.type == 1)
				cnt--;
			prev = e.val;
		}
		for (int i = 0; i <= n; i++) {
			out.println(prob[i] / (2 * l * (vLine + vAnton)));
		}

	}

	public void run() {
		try {
			in = new FastScanner();
			out = new PrintWriter(System.out);

			solve();

			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}
	}

	public static void main(String[] arg) {
		new C().run();
	}
}