Anton came to a chocolate factory. There he found a working conveyor and decided to run on it from the beginning to the end.

The conveyor is a looped belt with a total length of 2l meters, of which l meters are located on the surface and are arranged in a straight line. The part of the belt which turns at any moment (the part which emerges from under the floor to the surface and returns from the surface under the floor) is assumed to be negligibly short.

The belt is moving uniformly at speed v1 meters per second. Anton will be moving on it in the same direction at the constant speed of v2 meters per second, so his speed relatively to the floor will be v1 + v2 meters per second. Anton will neither stop nor change the speed or the direction of movement.

Here and there there are chocolates stuck to the belt (n chocolates). They move together with the belt, and do not come off it. Anton is keen on the chocolates, but he is more keen to move forward. So he will pick up all the chocolates he will pass by, but nothing more. If a chocolate is at the beginning of the belt at the moment when Anton starts running, he will take it, and if a chocolate is at the end of the belt at the moment when Anton comes off the belt, he will leave it.

<image> The figure shows an example with two chocolates. One is located in the position a1 = l - d, and is now on the top half of the belt, the second one is in the position a2 = 2l - d, and is now on the bottom half of the belt. 

You are given the positions of the chocolates relative to the initial start position of the belt 0 ≤ a1 < a2 < ... < an < 2l. The positions on the belt from 0 to l correspond to the top, and from l to 2l — to the the bottom half of the belt (see example). All coordinates are given in meters.

Anton begins to run along the belt at a random moment of time. This means that all possible positions of the belt at the moment he starts running are equiprobable. For each i from 0 to n calculate the probability that Anton will pick up exactly i chocolates.

Input

The first line contains space-separated integers n, l, v1 and v2 (1 ≤ n ≤ 105, 1 ≤ l, v1, v2 ≤ 109) — the number of the chocolates, the length of the conveyor's visible part, the conveyor's speed and Anton's speed.

The second line contains a sequence of space-separated integers a1, a2, ..., an (0 ≤ a1 < a2 < ... < an < 2l) — the coordinates of the chocolates.

Output

Print n + 1 numbers (one per line): the probabilities that Anton picks up exactly i chocolates, for each i from 0 (the first line) to n (the last line). The answer will be considered correct if each number will have absolute or relative error of at most than 10 - 9.

Examples

Input

1 1 1 1
0


Output

0.75000000000000000000
0.25000000000000000000


Input

2 3 1 2
2 5


Output

0.33333333333333331000
0.66666666666666663000
0.00000000000000000000

Note

In the first sample test Anton can pick up a chocolate if by the moment he starts running its coordinate is less than 0.5; but if by the moment the boy starts running the chocolate's coordinate is greater than or equal to 0.5, then Anton won't be able to pick it up. As all positions of the belt are equiprobable, the probability of picking up the chocolate equals <image>, and the probability of not picking it up equals <image>.
import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class C {

	private static void solve() throws IOException {
		int n = nextInt();
		int length = nextInt();
		int v1 = nextInt(), v2 = nextInt();
		int[] candy = new int[n];
		for (int i = 0; i < n; i++) {
			candy[i] = nextInt();
		}

		Rational anton = new Rational((long) length * v2, v1 + v2);
		double antonDouble = anton.doubleValue();

		int weEat = 0;
		List<Event> events = new ArrayList<Event>();
		for (int i = 0; i < n; i++) {
			for (int it = 0; it < 2; it++) {
				double lose = candy[i] + it * 2L * length;
//				Rational lose = new Rational(candy[i] + it * 2L * length);
				Event loseEvent = new Event(lose, false);
				events.add(loseEvent);
				double gain = lose - (antonDouble);
				if (gain < 0) {
					++weEat;
				} else {
					Event gainEvent = new Event(gain, true);
					events.add(gainEvent);
				}
			}
		}
		double lastEvent = 0;
		Collections.sort(events);

		Rational thisEnds = new Rational(2 * length, 1);
		double thisEndsDouble = thisEnds.doubleValue();
		double[] answer = new double[n + 1];

		for (Event e : events) {
			double segment;
			boolean breakAfter = false;
			if (e.time  < thisEndsDouble) {
				segment = e.time - lastEvent;
			} else {
				segment = 2 * length - lastEvent;
				breakAfter = true;
			}
			if (weEat >= 0 && weEat <= n) {
			answer[weEat] += segment;
			}
			if (e.add) {
				++weEat;
			} else {
				--weEat;
			}

			if (breakAfter) {
				break;
			}
			lastEvent = e.time;
		}
		
		for (int i = 0; i <= n; i++) {
			out.println(answer[i] / (2 * length));
		}
		

	}

	static class Event implements Comparable<Event> {
		double time;
		boolean add;

		private Event(double time, boolean add) {
			this.time = time;
			this.add = add;
		}

		@Override
		public int compareTo(Event o) {
			int cmp = Double.compare(time, o.time);
			if (cmp != 0) {
				return cmp;
			}
			if (add != o.add) {
				return !add ? -1 : 1;
			}
			return 0;
		}
	}

	public static class Rational implements Comparable<Rational> {
		BigInteger num;
		BigInteger den;

		public static final Rational ZERO = new Rational(0);
		public static final Rational ONE = new Rational(1);
		public static final Rational TWO = new Rational(2);
		public static final Rational POSITIVE_INFINITY = new Rational(1, 0);
		public static final Rational NEGATIVE_INFINITY = new Rational(-1, 0);

		public Rational(long num) {
			this.num = BigInteger.valueOf(num);
			this.den = BigInteger.ONE;
		}

		public Rational(long num, long den) {
			this.num = BigInteger.valueOf(num);
			this.den = BigInteger.valueOf(den);
			// reduce();
		}

		public Rational(BigInteger num, BigInteger den) {
			this.num = num;
			this.den = den;
			// reduce();
		}

		void reduce() {
			BigInteger gcd = num.gcd(den);
			if (gcd.signum() != 0) {
				num = num.divide(gcd);
				den = den.divide(gcd);
			}
			if (den.signum() < 0) {
				num = num.negate();
				den = den.negate();
			}
		}

		public Rational add(Rational r) {
			return new Rational(num.multiply(r.den).add(r.num.multiply(den)), den.multiply(r.den));
		}

		public Rational sub(Rational r) {
			return new Rational(num.multiply(r.den).subtract(r.num.multiply(den)),
					den.multiply(r.den));
		}

		public Rational mul(Rational r) {
			return new Rational(num.multiply(r.num), den.multiply(r.den));
		}

		public Rational div(Rational r) {
			return new Rational(num.multiply(r.den), den.multiply(r.num));
		}

		public Rational negate() {
			return new Rational(num.negate(), den);
		}

		public Rational inverse() {
			return new Rational(den, num);
		}

		public Rational abs() {
			return new Rational(num.abs(), den);
		}

		public int signum() {
			return num.signum();
		}

		public double doubleValue() {
			return num.doubleValue() / den.doubleValue();
		}

		public int compareTo(Rational other) {
			return (num.multiply(other.den).compareTo(other.num.multiply(den)));
		}

		public boolean equals(Object obj) {
			return obj instanceof Rational && num.equals(((Rational) obj).num)
					&& den.equals(((Rational) obj).den);
		}

		public int hashCode() {
			return num.hashCode() * 31 + den.hashCode();
		}

		public String toString() {
			return num + "/" + den;
		}
	}

	public static void main(String[] args) {
		try {
			br = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			solve();
			out.close();
		} catch (Throwable e) {
			e.printStackTrace();
			System.exit(239);
		}
	}

	static BufferedReader br;
	static StringTokenizer st;
	static PrintWriter out;

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

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

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

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