#include <cstdio>

int N;
double L, V1, V2;
double arr[200001];
double pre[200001];
double nxt[200001];
double ans[100001];

inline double min(double a, double b){return a < b? a: b;}
inline double max(double a, double b){return a > b? a: b;}

int main(){
	scanf("%d%lf%lf%lf", &N, &L, &V1, &V2);
	double len = L * (V2 / (V1 + V2));
	for(int i = 0; i < N; i++){
		scanf("%lf", &arr[i]);
		arr[i + N] = arr[i] + L * 2;
	}
	pre[0] = arr[N - 1] - L * 2;
	nxt[N * 2 - 1] = arr[0] + L * 2;
	for(int i = 1; i < N * 2; i++)
		pre[i] = arr[i - 1];
	for(int i = 0; i < N * 2 - 1; i++)
		nxt[i] = arr[i + 1];
	for(int i = 0, j = 0; i < N; i++){
		//printf("i = %d %lf %lf %lf\n", i, arr[i], len, arr[j]);
		while(arr[i] + len >= arr[j]){
			double left = max(pre[i], arr[j] - len);
			double right = min(arr[i], nxt[j] - len);
			if(right > left) ans[j - i + 1] += (right - left) / (L * 2);
			//printf("%d %d: %lf %lf %lf\n", i, j, left, right, nxt[j]);
			++j;
		}
	}
	ans[0] = 1.0;
	for(int i = 1; i <= N; i++)
		ans[0] -= ans[i];
	for(int i = 0; i <= N; i++)
		printf("%.15lf\n", ans[i]);
}


#include <cstdio>

int N;
double L, V1, V2;
double arr[200001];
double pre[200001];
double nxt[200001];
double ans[100001];

inline double min(double a, double b){return a < b? a: b;}
inline double max(double a, double b){return a > b? a: b;}

int main(){
	scanf("%d%lf%lf%lf", &N, &L, &V1, &V2);
	double len = L * (V2 / (V1 + V2));
	for(int i = 0; i < N; i++){
		scanf("%lf", &arr[i]);
		arr[i + N] = arr[i] + L * 2;
	}
	pre[0] = arr[N - 1] - L * 2;
	nxt[N * 2 - 1] = arr[0] + L * 2;
	for(int i = 1; i < N * 2; i++)
		pre[i] = arr[i - 1];
	for(int i = 0; i < N * 2 - 1; i++)
		nxt[i] = arr[i + 1];
	for(int i = 0, j = 0; i < N; i++){
		if(i > j)++j;
		//printf("i = %d %lf %lf %lf\n", i, arr[i], len, arr[j]);
		while(arr[i] + len >= arr[j]){
			double left = max(pre[i], arr[j] - len);
			double right = min(arr[i], nxt[j] - len);
			if(right > left) ans[j - i + 1] += right - left;
			//printf("%d %d: %lf %lf %lf\n", i, j, left, right, nxt[j]);
			++j;
		}
		--j;
	}
	ans[0] = 1.0;
	for(int i = 1; i <= N; i++)
		ans[0] -= (ans[i] /= (L * 2.0));
	for(int i = 0; i <= N; i++)
		printf("%.15lf\n", ans[i]);
}


#include <cstdio>

int N;
double L, V1, V2;
double arr[200001];
double pre[200001];
double nxt[200001];
double ans[100001];

inline double min(double a, double b){return a < b? a: b;}
inline double max(double a, double b){return a > b? a: b;}

int main(){
	scanf("%d%lf%lf%lf", &N, &L, &V1, &V2);
	double len = L * (V2 / (V1 + V2));
	for(int i = 0; i < N; i++){
		scanf("%lf", &arr[i]);
		arr[i + N] = arr[i] + L * 2;
	}
	pre[0] = arr[N - 1] - L * 2;
	nxt[N * 2 - 1] = arr[0] + L * 2;
	for(int i = 1; i < N * 2; i++)
		pre[i] = arr[i - 1];
	for(int i = 0; i < N * 2 - 1; i++)
		nxt[i] = arr[i + 1];
	for(int i = 0, j = 0; i < N; i++){
		//printf("i = %d %lf %lf %lf\n", i, arr[i], len, arr[j]);
		while(arr[i] + len >= arr[j]){
			double left = max(pre[i], arr[j] - len);
			double right = min(arr[i], nxt[j] - len);
			if(right > left) ans[j - i + 1] += right - left;
			//printf("%d %d: %lf %lf %lf\n", i, j, left, right, nxt[j]);
			++j;
		}
	}
	ans[0] = 1.0;
	for(int i = 1; i <= N; i++)
		ans[0] -= (ans[i] /= (L * 2.0));
	for(int i = 0; i <= N; i++)
		printf("%.15lf\n", ans[i]);
}


#ifdef _WIN32
#  define LL "%I64d"
#else
#  define LL "%Ld"
#endif

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <ctime>
#include <vector>
#include <deque>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <bitset>
#include <string>
#include <algorithm>
#include <complex>
#include <utility>
#include <cassert>
using namespace std;
#define null NULL
#define mp make_pair
#define pb(a) push_back(a)
#define sz(a) ((int)(a).size())
#define all(a) a.begin() , a.end()
#define fi first
#define se second
#define relaxMin(a , b) (a) = min((a),(b))
#define relaxMax(a , b) (a) = max((a),(b))
#define SQR(a) ((a)*(a))
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef long long ll;
#define EPS 1E-9
int N , L , V1 , V2;
vi pts;
double ans[100010];
bool eq(double a , double b){
  return fabs(a - b) < EPS;
}
int main(){
  scanf("%d%d%d%d" , &N , &L , &V1 , &V2);
  pts.resize(2*N);
  for(int i=0;i<2*N;i += 2)
   scanf("%d" , &pts[i]),
   pts[i+1] = 2*L + pts[i];
  sort(all(pts));
  double D = (L * 1.0 * V2) / (V1 + V2);
  double last = 0;
  int lo = 0 , hi = -1;
  while(hi+1 < sz(pts) && pts[hi+1] < D - lo)
   ++hi;
  for(;;){
   if(last > 2*L - EPS) break;
   double mv = 2*L - last;
   if(lo <= hi)
    relaxMin(mv , pts[lo] - last);
   if(hi+1 < sz(pts))
    relaxMin(mv , pts[hi+1] - last - D);
   ans[hi - lo + 1] += mv;
   if(lo <= hi && eq(mv , pts[lo] - last))
    ++lo;
   if(hi+1 < sz(pts) && eq(mv , pts[hi+1] - last - D))
    ++hi;
   last += mv;
         }
  for(int i=0;i<=N;++i)
   printf("%.12lf\n" , ans[i] / (2*L));
  return 0;
}


#ifdef _WIN32
#  define LL "%I64d"
#else
#  define LL "%Ld"
#endif

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <ctime>
#include <vector>
#include <deque>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <bitset>
#include <string>
#include <algorithm>
#include <complex>
#include <utility>
#include <cassert>
using namespace std;
#define null NULL
#define mp make_pair
#define pb(a) push_back(a)
#define sz(a) ((int)(a).size())
#define all(a) a.begin() , a.end()
#define fi first
#define se second
#define relaxMin(a , b) (a) = min((a),(b))
#define relaxMax(a , b) (a) = max((a),(b))
#define SQR(a) ((a)*(a))
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef long long ll;
#define EPS 1E-9
int N , L , V1 , V2;
vi pts;
double ans[100010];
bool eq(double a , double b){
  return fabs(a - b) < EPS;
}
int main(){
  scanf("%d%d%d%d" , &N , &L , &V1 , &V2);
  pts.resize(2*N);
  for(int i=0;i<2*N;i += 2)
   scanf("%d" , &pts[i]),
   pts[i+1] = 2*L + pts[i];
  sort(all(pts));
  double D = (L * 1.0 * V2) / (V1 + V2);
  double last = 0;
  int lo = 0 , hi = -1;
  while(hi+1 < sz(pts) && pts[hi+1] < D - EPS)
   ++hi;
  for(;;){
   if(last > 2*L - EPS) break;
   double mv = 2*L - last;
   if(lo <= hi)
    relaxMin(mv , pts[lo] - last);
   if(hi+1 < sz(pts))
    relaxMin(mv , pts[hi+1] - last - D);
   ans[hi - lo + 1] += mv;
   if(lo <= hi && eq(mv , pts[lo] - last))
    ++lo;
   if(hi+1 < sz(pts) && eq(mv , pts[hi+1] - last - D))
    ++hi;
   last += mv;
         }
  for(int i=0;i<=N;++i)
   printf("%.12lf\n" , ans[i] / (2*L));
  return 0;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <deque>
#include <bitset>
#include <set>
#include <map>
#include <utility>
#include <string>
#include <cstring>
#include <queue>
#include <algorithm>
#include <cmath>
using namespace std;
#define fi first
#define se second
#define pb(a) push_back(a)
#define sz(a) ((int)(a).size())
#define all(a) a.begin() , a.end()
#define EPS 1E-9
#define x1 x111
#define y1 y111
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int,int> pii;
// real solution
double N,L,v1,v2;
map<double,int> beg , stop;
double sum[100010];
double D;
int main(){
  cin>>N>>L>>v1>>v2;
  D=L/(v1+v2); D*=v2;
  for(int i=0;i<N;++i){
   int P; scanf("%d",&P);
   double p=P;
   ++beg[ max(0.0 , p-D) ];
   ++stop[ max(0.0 , p) ];
   p+=2*L;
   ++beg[ max(0.0 , p-D) ];
   ++stop[ max(0.0 , p) ];
                      }
  double last=0.0; int how=0;
  while(!beg.empty() || !stop.empty()){
   double CT=1E18;
   if(!beg.empty())CT=min(CT , beg.begin()->fi);
   if(!stop.empty())CT=min(CT , stop.begin()->fi);
   int st=beg[CT] , en=stop[CT];
   beg.erase(CT); stop.erase(CT);
   sum[how] += min(CT , 2*L)-last;
   last=CT; if(last>2*L)break;
   how+=st;
   how-=en;
                                      }
  if(last<2*L)sum[how]+=(2*L-last);
  for(int i=0;i<=N;++i)
   printf("%.12lf\n" , sum[i]/(2*L));
  //system("pause");
  return 0;
}


#ifdef _WIN32
#  define LL "%I64d"
#else
#  define LL "%Ld"
#endif

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <ctime>
#include <vector>
#include <deque>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <bitset>
#include <string>
#include <algorithm>
#include <complex>
#include <utility>
#include <cassert>
using namespace std;
#define null NULL
#define mp make_pair
#define pb(a) push_back(a)
#define sz(a) ((int)(a).size())
#define all(a) a.begin() , a.end()
#define fi first
#define se second
#define relaxMin(a , b) (a) = min((a),(b))
#define relaxMax(a , b) (a) = max((a),(b))
#define SQR(a) ((a)*(a))
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef long long ll;
#define EPS 1E-9
int N , L , V1 , V2;
vi pts;
double ans[100010];
bool eq(double a , double b){
  return fabs(a - b) < EPS;
}
int main(){
  scanf("%d%d%d%d" , &N , &L , &V1 , &V2);
  pts.resize(2*N);
  for(int i=0;i<2*N;i += 2)
   scanf("%d" , &pts[i]),
   pts[i+1] = 2*L + pts[i];
  sort(all(pts));
  double D = (L * 1.0 * V2) / (V1 + V2);
  double last = 0;
  int lo = 0 , hi = -1;
  while(hi+1 < sz(pts) && pts[hi+1] < D - EPS)
   ++hi;
  for(;;){
   if(last > 2*L - EPS) break;
   double mv = 2*L - last , npos = 2*L;
   if(lo <= hi)
    relaxMin(mv , pts[lo] - last),
    relaxMin(npos , double(pts[lo]));
   if(hi+1 < sz(pts))
    relaxMin(mv , pts[hi+1] - last - D),
    relaxMin(npos , pts[hi+1] - D);
   ans[hi - lo + 1] += mv;
   if(lo <= hi && eq(mv , pts[lo] - last))
    ++lo;
   if(hi+1 < sz(pts) && eq(mv , pts[hi+1] - last - D))
    ++hi;
   last = npos;
         }
  for(int i=0;i<=N;++i)
   printf("%.12lf\n" , ans[i] / (2*L));
  return 0;
}


#ifdef _WIN32
#  define LL "%I64d"
#else
#  define LL "%Ld"
#endif

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <ctime>
#include <vector>
#include <deque>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <bitset>
#include <string>
#include <algorithm>
#include <complex>
#include <utility>
#include <cassert>
using namespace std;
#define null NULL
#define mp make_pair
#define pb(a) push_back(a)
#define sz(a) ((int)(a).size())
#define all(a) a.begin() , a.end()
#define fi first
#define se second
#define relaxMin(a , b) (a) = min((a),(b))
#define relaxMax(a , b) (a) = max((a),(b))
#define SQR(a) ((a)*(a))
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef long long ll;
#define EPS 1E-9
int N , L , V1 , V2;
vector<ll> pts;
double ans[100010];
bool eq(double a , double b){
  return fabs(a - b) < EPS;
}
int main(){
  scanf("%d%d%d%d" , &N , &L , &V1 , &V2);
  double D = (L * 1.0 * V2) / (V1 + V2);
  pts.resize(2*N);
  for(int i=0;i<2*N;i += 2)
   scanf(LL , &pts[i]),
   pts[i+1] = 2*L + pts[i];
  sort(all(pts));
  double last = 0;
  int lo = 0 , hi = -1;
  while(hi+1 < sz(pts) && pts[hi+1] < D - EPS)
   ++hi;
  for(;;){
   if(last > 2*L - EPS) break;
   double mv = 2*L - last , npos = 2*L;
   if(lo <= hi)
    relaxMin(mv , pts[lo] - last),
    relaxMin(npos , double(pts[lo]));
   if(hi+1 < sz(pts))
    relaxMin(mv , pts[hi+1] - last - D),
    relaxMin(npos , pts[hi+1] - D);
   ans[hi - lo + 1] += mv;
   if(lo <= hi && eq(mv , pts[lo] - last))
    ++lo;
   if(hi+1 < sz(pts) && eq(mv , pts[hi+1] - last - D))
    ++hi;
   last = npos;
         }
  for(int i=0;i<=N;++i)
   printf("%.12lf\n" , ans[i] / (2*L));
  return 0;
}


#ifdef _WIN32
#  define LL "%I64d"
#else
#  define LL "%Ld"
#endif

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <ctime>
#include <vector>
#include <deque>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <bitset>
#include <string>
#include <algorithm>
#include <complex>
#include <utility>
#include <cassert>
using namespace std;
#define null NULL
#define mp make_pair
#define pb(a) push_back(a)
#define sz(a) ((int)(a).size())
#define all(a) a.begin() , a.end()
#define fi first
#define se second
#define relaxMin(a , b) (a) = min((a),(b))
#define relaxMax(a , b) (a) = max((a),(b))
#define SQR(a) ((a)*(a))
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef long long ll;
#define EPS 1E-9
int N , L , V1 , V2;
vector<ll> pts;
double ans[200010];
bool eq(double a , double b){
  return fabs(a - b) < EPS;
}
int main(){
  scanf("%d%d%d%d" , &N , &L , &V1 , &V2);
  double D = (L * 1.0 * V2) / (V1 + V2);
  for(int i=0,a;i<N;++i)
   scanf("%d" , &i),
   pts.pb(a) , pts.pb(2LL*L + a);
  sort(all(pts));
  double last = 0;
  int lo = 0 , hi = -1;
  while(hi+1 < sz(pts) && pts[hi+1] < D - EPS)
   ++hi;
  for(;;){
   if(last >= 2*L) break;
   double mv = 2*L - last , npos = 2*L;
   if(lo <= hi)
    relaxMin(mv , pts[lo] - last),
    relaxMin(npos , double(pts[lo]));
   if(hi+1 < sz(pts))
    relaxMin(mv , pts[hi+1] - last - D),
    relaxMin(npos , pts[hi+1] - D);
   ans[hi - lo + 1] += mv;
   if(lo <= hi && eq(mv , pts[lo] - last))
    ++lo;
   if(hi+1 < sz(pts) && eq(mv , pts[hi+1] - last - D))
    ++hi;
   last = npos;
         }
  for(int i=0;i<=N;++i)
   printf("%.12lf\n" , ans[i] / (2*L));
  return 0;
}


#ifdef _WIN32
#  define LL "%I64d"
#else
#  define LL "%Ld"
#endif

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <ctime>
#include <vector>
#include <deque>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <bitset>
#include <string>
#include <algorithm>
#include <complex>
#include <utility>
#include <cassert>
using namespace std;
#define null NULL
#define mp make_pair
#define pb(a) push_back(a)
#define sz(a) ((int)(a).size())
#define all(a) a.begin() , a.end()
#define fi first
#define se second
#define relaxMin(a , b) (a) = min((a),(b))
#define relaxMax(a , b) (a) = max((a),(b))
#define SQR(a) ((a)*(a))
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef long long ll;
#define EPS 1E-9
int N , L , V1 , V2;
vector<ll> pts;
double ans[100010];
bool eq(double a , double b){
  return fabs(a - b) < EPS;
}
int main(){
  scanf("%d%d%d%d" , &N , &L , &V1 , &V2);
  double D = (L * 1.0 * V2) / (V1 + V2);
  pts.resize(2*N);
  for(int i=0;i<2*N;i += 2){
   int a; scanf("%d" , &a);
   pts[i] = a;
   pts[i+1] = 2LL*L + a;
                           }
  sort(all(pts));
  double last = 0;
  int lo = 0 , hi = -1;
  while(hi+1 < sz(pts) && pts[hi+1] < D - EPS)
   ++hi;
  for(;;){
   if(last >= 2*L) break;
   double mv = 2*L - last , npos = 2*L;
   if(lo <= hi)
    relaxMin(mv , pts[lo] - last),
    relaxMin(npos , double(pts[lo]));
   if(hi+1 < sz(pts))
    relaxMin(mv , pts[hi+1] - last - D),
    relaxMin(npos , pts[hi+1] - D);
   ans[hi - lo + 1] += mv;
   if(lo <= hi && eq(mv , pts[lo] - last))
    ++lo;
   if(hi+1 < sz(pts) && eq(mv , pts[hi+1] - last - D))
    ++hi;
   last = npos;
         }
  for(int i=0;i<=N;++i)
   printf("%.12lf\n" , ans[i] / (2*L));
  return 0;
}


#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>
#include <algorithm>
#include <string>
#include <vector>

using namespace std;

#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#define pb push_back
#define mp make_pair
#define sz(x) ((int)(x).size())

typedef long long ll;
typedef vector<ll> vll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef pair<int, int> pii;

#define EPS 1e-11
bool cmp(double a, double b) { return fabs(a - b) < EPS; }

int main() {
  #ifdef DEBUG
  freopen("std.in", "r", stdin);
  freopen("std.out", "w", stdout);
  #endif

  int n, l, v1, v2;
  while (scanf("%d%d%d%d", &n, &l, &v1, &v2) >= 1) {
    vi as(n);
    for (int i = 0; i < n; i++)
      scanf("%d", &as[i]);
    sort(as.begin(), as.end());
    as.resize(n + n);
    for (int i = 0; i < n; i++) as[i + n] = as[i] + 2 * l;

    double slen = double(l) * v2 / double(v1 + v2);
    eprintf("slen=%.2lf\n", slen);

    vector<pair<double, int> > evs;
    vector<double> xs;
    for (int i = 0; i < sz(as); i++) {
      evs.pb(mp(as[i] - slen, 1));
      evs.pb(mp(as[i], -1));

      if (as[i] - slen > EPS && as[i] - slen < 2 * l - EPS)
        xs.pb(as[i] - slen);
      if (as[i] > EPS && as[i] < 2 * l - EPS)
        xs.pb(as[i]);
    }
    xs.pb(0); xs.pb(2 * l);
    sort(evs.begin(), evs.end());
    sort(xs.begin(), xs.end());
    xs.erase(unique(xs.begin(), xs.end(), cmp), xs.end());

    int ptr = 0;
    int ccnt = 0;

    vector<double> res(n + 1);
    for (int i = 0; i + 1 < sz(xs); i++) {
      while (ptr < sz(evs) && evs[ptr].first <= xs[i] + EPS)
        ccnt += evs[ptr++].second;
      double clen = xs[i + 1] - xs[i];
      res[ccnt] += clen;
    }
    for (int i = 0; i <= n; i++)
      printf("%.18lf\n", res[i] / 2 / l);
  }
  return 0;
}


#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>
#include <algorithm>
#include <string>
#include <vector>

using namespace std;

#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#define pb push_back
#define mp make_pair
#define sz(x) ((int)(x).size())

typedef long long ll;
typedef vector<ll> vll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef pair<int, int> pii;

#define EPS 1e-8
bool cmp(double a, double b) { return fabs(a - b) < EPS; }

int main() {
  #ifdef DEBUG
  freopen("std.in", "r", stdin);
  freopen("std.out", "w", stdout);
  #endif

  int n, l, v1, v2;
  while (scanf("%d%d%d%d", &n, &l, &v1, &v2) >= 1) {
    vi as(n);
    for (int i = 0; i < n; i++)
      scanf("%d", &as[i]);
    sort(as.begin(), as.end());
    as.resize(n + n);
    for (int i = 0; i < n; i++) as[i + n] = as[i] + 2 * l;

    double slen = double(l) * v2 / double(v1 + v2);
    eprintf("slen=%.2lf\n", slen);

    vector<pair<double, int> > evs;
    vector<double> xs;
    for (int i = 0; i < sz(as); i++) {
      evs.pb(mp(as[i] - slen, 1));
      evs.pb(mp(as[i], -1));

      if (as[i] - slen > EPS && as[i] - slen < 2 * l - EPS)
        xs.pb(as[i] - slen);
      if (as[i] > EPS && as[i] < 2 * l - EPS)
        xs.pb(as[i]);
    }
    xs.pb(0); xs.pb(2 * l);
    sort(evs.begin(), evs.end());
    sort(xs.begin(), xs.end());
    xs.erase(unique(xs.begin(), xs.end(), cmp), xs.end());

    int ptr = 0;
    int ccnt = 0;

    vector<double> res(n + 1);
    for (int i = 0; i + 1 < sz(xs); i++) {
      while (ptr < sz(evs) && evs[ptr].first <= xs[i] + EPS)
        ccnt += evs[ptr++].second;

      #ifdef DEBUG
      int rcnt = 0;
      for (int i2 = 0; i2 < sz(as); i2++)
        rcnt += xs[i] + EPS < as[i2] && as[i2] <= xs[i] + slen + EPS;
      assert(rcnt == ccnt);
      #endif
      double clen = xs[i + 1] - xs[i];
      res[ccnt] += clen;
    }
    for (int i = 0; i <= n; i++)
      printf("%.18lf\n", res[i] / 2 / l);
  }
  return 0;
}


#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>
#include <algorithm>
#include <string>
#include <vector>

using namespace std;

#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#define pb push_back
#define mp make_pair
#define sz(x) ((int)(x).size())

typedef long long ll;
typedef vector<ll> vll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef pair<int, int> pii;

#define EPS 1e-8
bool cmp(double a, double b) { return fabs(a - b) < EPS; }

int main() {
  #ifdef DEBUG
  freopen("std.in", "r", stdin);
  freopen("std.out", "w", stdout);
  #endif

  int n, l, v1, v2;
  while (scanf("%d%d%d%d", &n, &l, &v1, &v2) >= 1) {
    vi as(n);
    for (int i = 0; i < n; i++)
      scanf("%d", &as[i]);
    sort(as.begin(), as.end());
    as.resize(n + n);
    for (int i = 0; i < n; i++) as[i + n] = as[i] + 2 * l;

    double slen = double(l) * v2 / double(v1 + v2);
    eprintf("slen=%.2lf\n", slen);

    vector<pair<double, int> > evs;
    vector<double> xs;
    for (int i = 0; i < sz(as); i++) {
      evs.pb(mp(as[i] - slen, 1));
      evs.pb(mp(as[i], -1));

      if (as[i] - slen > EPS && as[i] - slen < 2 * l - EPS)
        xs.pb(as[i] - slen);
      if (as[i] > EPS && as[i] < 2 * l - EPS)
        xs.pb(as[i]);
    }
    xs.pb(0); xs.pb(2 * l);
    sort(evs.begin(), evs.end());
    sort(xs.begin(), xs.end());
    xs.erase(unique(xs.begin(), xs.end(), cmp), xs.end());

    int ptr = 0;
    int ccnt = 0;

    vector<double> res(n + 1);
    for (int i = 0; i + 1 < sz(xs); i++) {
      while (ptr < sz(evs) && evs[ptr].first <= xs[i] + EPS)
        ccnt += evs[ptr++].second;
      double clen = xs[i + 1] - xs[i];
      res[ccnt] += clen;
    }
    for (int i = 0; i <= n; i++)
      printf("%.18lf\n", res[i] / 2 / l);
  }
  return 0;
}


#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>
#include <algorithm>
#include <string>
#include <vector>

using namespace std;

#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#define pb push_back
#define mp make_pair
#define sz(x) ((int)(x).size())

typedef long long ll;
typedef vector<ll> vll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef pair<int, int> pii;

#define EPS 1e-8
bool cmp(double a, double b) { return fabs(a - b) < EPS; }

int main() {
  #ifdef DEBUG
  freopen("std.in", "r", stdin);
  freopen("std.out", "w", stdout);
  #endif

  int n, l, v1, v2;
  while (scanf("%d%d%d%d", &n, &l, &v1, &v2) >= 1) {
    vll as(n);
    for (int i = 0; i < n; i++)
      scanf("%I64d", &as[i]);
    sort(as.begin(), as.end());
    as.resize(n + n);
    for (int i = 0; i < n; i++) as[i + n] = as[i] + 2ll * l;

    double slen = double(l) * v2 / double(v1 + v2);
    eprintf("slen=%.2lf\n", slen);

    vector<pair<double, int> > evs;
    vector<double> xs;
    for (int i = 0; i < sz(as); i++) {
      evs.pb(mp(as[i] - slen, 1));
      evs.pb(mp(as[i], -1));

      if (as[i] - slen > EPS && as[i] - slen < 2 * l - EPS)
        xs.pb(as[i] - slen);
      if (as[i] > EPS && as[i] < 2 * l - EPS)
        xs.pb(as[i]);
    }
    xs.pb(0); xs.pb(2 * l);
    sort(evs.begin(), evs.end());
    sort(xs.begin(), xs.end());
    xs.erase(unique(xs.begin(), xs.end(), cmp), xs.end());

    int ptr = 0;
    int ccnt = 0;

    vector<double> res(n + 1);
    for (int i = 0; i + 1 < sz(xs); i++) {
      while (ptr < sz(evs) && evs[ptr].first <= xs[i] + EPS) {
        ccnt += evs[ptr++].second;
      }

      double clen = xs[i + 1] - xs[i];
      res[ccnt] += clen;
    }
    for (int i = 0; i <= n; i++)
      printf("%.18lf\n", res[i] / 2 / l);
  }
  return 0;
}


#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>
#include <algorithm>
#include <string>
#include <vector>

using namespace std;

#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#define pb push_back
#define mp make_pair
#define sz(x) ((int)(x).size())

typedef long long ll;
typedef vector<ll> vll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef pair<int, int> pii;

#define EPS 1e-8
bool cmp(double a, double b) { return fabs(a - b) < EPS; }

int main() {
  #ifdef DEBUG
  freopen("std.in", "r", stdin);
  freopen("std.out", "w", stdout);
  #endif

  int n, l, v1, v2;
  while (scanf("%d%d%d%d", &n, &l, &v1, &v2) >= 1) {
    vi as(n);
    for (int i = 0; i < n; i++)
      scanf("%d", &as[i]);
    sort(as.begin(), as.end());
    as.resize(n + n);
    for (int i = 0; i < n; i++) as[i + n] = as[i] + 2 * l;

    double slen = double(l) * v2 / double(v1 + v2);
    eprintf("slen=%.2lf\n", slen);

    vector<pair<double, int> > evs;
    vector<double> xs;
    for (int i = 0; i < sz(as); i++) {
      evs.pb(mp(as[i] - slen, 1));
      evs.pb(mp(as[i], -1));

      if (as[i] - slen > EPS && as[i] - slen < 2 * l - EPS)
        xs.pb(as[i] - slen);
      if (as[i] > EPS && as[i] < 2 * l - EPS)
        xs.pb(as[i]);
    }
    xs.pb(0); xs.pb(2 * l);
    sort(evs.begin(), evs.end());
    sort(xs.begin(), xs.end());
    xs.erase(unique(xs.begin(), xs.end(), cmp), xs.end());

    int ptr = 0;
    int ccnt = 0;

    vector<double> res(n + 1);
    for (int i = 0; i + 1 < sz(xs); i++) {
      while (ptr < sz(evs) && evs[ptr].first <= xs[i] + EPS)
        ccnt += evs[ptr++].second;

      int rcnt = 0;
      for (int i2 = 0; i2 < sz(as); i2++)
        rcnt += xs[i] + EPS < as[i2] && as[i2] <= xs[i] + slen + EPS;
      assert(rcnt == ccnt);

      double clen = xs[i + 1] - xs[i];
      res[ccnt] += clen;
    }
    for (int i = 0; i <= n; i++)
      printf("%.18lf\n", res[i] / 2 / l);
  }
  return 0;
}


#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>
#include <algorithm>
#include <string>
#include <vector>

using namespace std;

#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#define pb push_back
#define mp make_pair
#define sz(x) ((int)(x).size())

typedef long long ll;
typedef vector<ll> vll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef pair<int, int> pii;

#define EPS 1e-8
bool cmp(double a, double b) { return fabs(a - b) < EPS; }

int main() {
  #ifdef DEBUG
  freopen("std.in", "r", stdin);
  freopen("std.out", "w", stdout);
  #endif

  int n, l, v1, v2;
  while (scanf("%d%d%d%d", &n, &l, &v1, &v2) >= 1) {
    vll as(n);
    for (int i = 0; i < n; i++)
      scanf("%I64d", &as[i]);
    sort(as.begin(), as.end());
    as.resize(n + n);
    for (int i = 0; i < n; i++) as[i + n] = as[i] + 2ll * l;

    double slen = double(l) * v2 / double(v1 + v2);
    eprintf("slen=%.2lf\n", slen);

    vector<pair<double, int> > evs;
    vector<double> xs;
    for (int i = 0; i < sz(as); i++) {
      evs.pb(mp(as[i] - slen, 1));
      evs.pb(mp(as[i], -1));

      if (as[i] - slen > EPS && as[i] - slen < 2 * l - EPS)
        xs.pb(as[i] - slen);
      if (as[i] > EPS && as[i] < 2 * l - EPS)
        xs.pb(as[i]);
    }
    xs.pb(0); xs.pb(2 * l);
    sort(evs.begin(), evs.end());
    sort(xs.begin(), xs.end());
    xs.erase(unique(xs.begin(), xs.end(), cmp), xs.end());

    int ptr = 0;
    int ccnt = 0;

    vector<double> res(n + 1);
    for (int i = 0; i + 1 < sz(xs); i++) {
      while (ptr < sz(evs) && evs[ptr].first <= xs[i] + EPS)
        ccnt += evs[ptr++].second;
      double clen = xs[i + 1] - xs[i];
      res[ccnt] += clen;
    }
    for (int i = 0; i <= n; i++)
      printf("%.18lf\n", res[i] / 2 / l);
  }
  return 0;
}


/*AMETHYSTS*/
#pragma comment(linker, "/STACK:1000000000")
#include <cstdio>
#include <iostream>
#include <ctime>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <set>
#include <map>
#include <cstdlib>
#include <ctime>
#include <cassert>
#include <bitset>
#include <deque>
#include <stack>
#include <climits>
#include <string>
#include <queue>
#include <memory.h>

#define ll long long
#define ld long double
#define pii pair <int, int>
#define forn(i, n) for (int i = 0; i < (int)n; i++)
#define mp make_pair
#define ui unsigned ll
#define pll pair <ll, ll>

using namespace std;

const int maxn = (int)2e5 + 10;

ll v[maxn];

ld ans[maxn];

int main() {
	int n;

	cin >> n;

	ll d, v1, v2;
	cin >> d >> v1 >> v2;

	vector <ld> t;

	ld x = (ld)v2 * d / (v1 + v2);

	for (int i = 0; i < n; i++) {
		scanf("%lld", &v[i]);
	}

	for (int i = 1; i < n; i++) {
		v[i] -= v[0];
	}

	v[0] = 0;

	for (int i = 0; i < n; i++) {
		t.push_back(v[i]);

		ld z = v[i] - x;

		if (z < 0) {
			z += 2 * d;
		}

		t.push_back(z);
	}

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

	for (int i = n; i < 2 * n; i++) {
		v[i] = v[i - n] + 2 * d;
	}

	int l = 0;
	int r = 0;

	for (int i = 0; i < (int)t.size(); i++) {
		while (l < 2 * n && v[l] <= t[i]) {
			l++;
		}

		while (r < 2 * n && t[i] + x >= v[r]) {
			r++;
		}

		if (i + 1 != (int)t.size()) {
			ans[r - l] += (t[i + 1] - t[i]);
		}
		else {
			ans[r - l] += (2 * d - t[i]);
		}
	}

	for (int i = 0; i <= n; i++) {
		printf("%.20lf\n", (double)(ans[i] / 2 / d));
	}
}


#include <iostream>
#include <stdio.h>
#include <cstring>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <ctime>
#include <cassert>
#include <unordered_map>
#include <fstream>
#include <random>
#include <cstring>
#include <complex>
#include <bitset>

#define all(a) (a).begin(), (a).end()
#define pb push_back
#define sz(a) (int)(a).size()

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef long double ld;

const double EPS = 1e-9;

int main() {
    // ifstream cin("input.txt");
    // ofstream cout("output.txt");
    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);

    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int n, m;
    cin >> n;
    int l, v1, v2;
    cin >> l >> v1 >> v2;

    vector<int> a(n);

    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

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

    vector<pair<double, int>> events;

    int cnt = 0;
    for (int i = 0; i < n; ++i) {
        if (a[i] - len > 0) {
            events.push_back({a[i] - len, 1});
            events.push_back({a[i], -1});
        } else {
            cnt += 1;
            events.push_back({2 * l + a[i] - len, 1});
            events.push_back({a[i], -1});
        }
    }
    events.push_back({2 * l, 0});

    sort(all(events));

    vector<double> res(n + 1);

    double tm = 0;
    for (int i = 0; i < sz(events); ++i) {
        // cout << events[i].first << " " << events[i].second << endl;
        if (cnt < n) {
            res[cnt] += events[i].first - tm;
        }
        tm = events[i].first;
        cnt += events[i].second;
    }

    cout.precision(12);
    cout << fixed;
    for (int i = 0; i <= n; ++i) {
        res[i] /= 2 * l;
        cout << res[i] << "\n";
    }
}


#include <iostream>
#include <stdio.h>
#include <cstring>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <ctime>
#include <cassert>
#include <unordered_map>
#include <fstream>
#include <random>
#include <cstring>
#include <complex>
#include <bitset>

#define all(a) (a).begin(), (a).end()
#define pb push_back
#define sz(a) (int)(a).size()

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef long double ld;

const double EPS = 1e-9;

int main() {
    // ifstream cin("input.txt");
    // ofstream cout("output.txt");
    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);

    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int n, m;
    cin >> n;
    int l, v1, v2;
    cin >> l >> v1 >> v2;

    vector<int> a(n);

    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

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

    vector<pair<double, int>> events;

    int cnt = 0;
    for (int i = 0; i < n; ++i) {
        if (a[i] - len > 0) {
            events.push_back({a[i] - len, 1});
            events.push_back({a[i], -1});
        } else {
            cnt += 1;
            events.push_back({2 * l + a[i] - len, 1});
            events.push_back({a[i], -1});
        }
    }
    events.push_back({2 * l, 0});

    sort(all(events));

    vector<double> res(n + 1);

    double tm = 0;
    for (int i = 0; i < sz(events); ++i) {
        // cout << events[i].first << " " << events[i].second << endl;
        if (0 <= cnt && cnt <= n) {
            res[cnt] += events[i].first - tm;
        }
        tm = events[i].first;
        cnt += events[i].second;
    }

    cout.precision(12);
    cout << fixed;
    for (int i = 0; i <= n; ++i) {
        res[i] /= 2 * l;
        cout << res[i] << "\n";
    }
}


#include <iostream>
#include <stdio.h>
#include <cstring>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <ctime>
#include <cassert>
#include <unordered_map>
#include <fstream>
#include <random>
#include <cstring>
#include <complex>
#include <bitset>

#define all(a) (a).begin(), (a).end()
#define pb push_back
#define sz(a) (int)(a).size()

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef long double ld;

const ld EPS = 1e-12;

int main() {
    // ifstream cin("input.txt");
    // ofstream cout("output.txt");
    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);

    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int n, m;
    cin >> n;
    int l, v1, v2;
    cin >> l >> v1 >> v2;

    vector<int> a(n);

    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

    ld len = (ld)(l * v2) / (v1 + v2);

    vector<pair<ld, int>> events;

    int cnt = 0;
    for (int i = 0; i < n; ++i) {
        if (a[i] - len >= 0) {
            events.push_back({a[i] - len, 1});
            events.push_back({a[i], -1});
        } else {
            cnt += 1;
            events.push_back({2 * l + a[i] - len, 1});
            events.push_back({a[i], -1});
        }
    }
    events.push_back({2 * l, 0});

    sort(all(events));

    vector<ld> res(n + 1);

    ld tm = 0;
    for (int i = 0; i < sz(events); ++i) {
        // cout << events[i].first << " " << events[i].second << endl;
        if (0 <= cnt && cnt <= n) {
            res[cnt] += events[i].first - tm;
        }
        tm = events[i].first;
        cnt += events[i].second;
    }

    cout.precision(12);
    cout << fixed;
    for (int i = 0; i <= n; ++i) {
        res[i] /= 2 * l;
        cout << res[i] << "\n";
    }
}


#include <iostream>
#include <stdio.h>
#include <cstring>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <ctime>
#include <cassert>
#include <unordered_map>
#include <fstream>
#include <random>
#include <cstring>
#include <complex>
#include <bitset>

#define all(a) (a).begin(), (a).end()
#define pb push_back
#define sz(a) (int)(a).size()

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef long double ld;

const double EPS = 1e-12;

int main() {
    // ifstream cin("input.txt");
    // ofstream cout("output.txt");
    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);

    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int n, m;
    cin >> n;
    int l, v1, v2;
    cin >> l >> v1 >> v2;

    vector<int> a(n);

    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

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

    vector<pair<double, int>> events;

    int cnt = 0;
    for (int i = 0; i < n; ++i) {
        if (a[i] - len >= -EPS) {
            events.push_back({a[i] - len, 1});
            events.push_back({a[i], -1});
        } else {
            cnt += 1;
            events.push_back({2 * l + a[i] - len, 1});
            events.push_back({a[i], -1});
        }
    }
    events.push_back({2 * l, 0});

    sort(all(events));

    vector<double> res(n + 1);

    double tm = 0;
    for (int i = 0; i < sz(events); ++i) {
        // cout << events[i].first << " " << events[i].second << endl;
        if (0 <= cnt && cnt <= n) {
            res[cnt] += events[i].first - tm;
        }
        tm = events[i].first;
        cnt += events[i].second;
    }

    cout.precision(12);
    cout << fixed;
    for (int i = 0; i <= n; ++i) {
        res[i] /= 2 * l;
        cout << res[i] << "\n";
    }
}


#include <iostream>
#include <stdio.h>
#include <cstring>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <ctime>
#include <cassert>
#include <unordered_map>
#include <fstream>
#include <random>
#include <cstring>
#include <complex>
#include <bitset>

#define all(a) (a).begin(), (a).end()
#define pb push_back
#define sz(a) (int)(a).size()

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef long double ld;

const double EPS = 1e-9;

int main() {
    // ifstream cin("input.txt");
    // ofstream cout("output.txt");
    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);

    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int n, m;
    cin >> n;
    int l, v1, v2;
    cin >> l >> v1 >> v2;

    vector<int> a(n);

    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

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

    vector<pair<double, int>> events;

    int cnt = 0;
    for (int i = 0; i < n; ++i) {
        if (a[i] - len > 0) {
            events.push_back({a[i] - len, 1});
            events.push_back({a[i], -1});
        } else {
            cnt += 1;
            events.push_back({2 * l + a[i] - len, 1});
            events.push_back({a[i], -1});
        }
    }
    events.push_back({2 * l, 0});

    sort(all(events));

    vector<double> res(n + 1);

    double tm = 0;
    for (int i = 0; i < sz(events); ++i) {
        // cout << events[i].first << " " << events[i].second << endl;
        if (cnt <= n) {
            res[cnt] += events[i].first - tm;
        }
        tm = events[i].first;
        cnt += events[i].second;
    }

    cout.precision(12);
    cout << fixed;
    for (int i = 0; i <= n; ++i) {
        res[i] /= 2 * l;
        cout << res[i] << "\n";
    }
}


#include <iostream>
#include <stdio.h>
#include <cstring>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <ctime>
#include <cassert>
#include <unordered_map>
#include <fstream>
#include <random>
#include <cstring>
#include <complex>
#include <bitset>

#define all(a) (a).begin(), (a).end()
#define pb push_back
#define sz(a) (int)(a).size()

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef long double ld;

const ld EPS = 1e-12;

int main() {
    // ifstream cin("input.txt");
    // ofstream cout("output.txt");
    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);

    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int n, m;
    cin >> n;
    int l, v1, v2;
    cin >> l >> v1 >> v2;

    vector<int> a(n);

    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

    ll len = (ll)l * v2;

    vector<pair<ll, int>> events;

    int cnt = 0;
    for (int i = 0; i < n; ++i) {
        if (a[i] * (v2 + v2) - len >= 0) {
            events.push_back({(ll)a[i] * (v1 + v2) - len, 1});
            events.push_back({(ll)a[i] * (v1 + v2), -1});
        } else {
            cnt += 1;
            events.push_back({(ll)(2 * l + a[i]) * (v1 + v2) - len, 1});
            events.push_back({(ll)a[i] * (v1 + v2), -1});
        }
    }
    events.push_back({(ll)2 * l * (v1 + v2), 0});

    sort(all(events));

    vector<ld> res(n + 1);

    ld tm = 0;
    for (int i = 0; i < sz(events); ++i) {
        // cout << events[i].first << " " << events[i].second << endl;
        if (0 <= cnt && cnt <= n) {
            res[cnt] += events[i].first - tm;
        }
        tm = events[i].first;
        cnt += events[i].second;
    }

    cout.precision(12);
    cout << fixed;
    for (int i = 0; i <= n; ++i) {
        res[i] /= (ll)2 * l * (v1 + v2);
        cout << res[i] << "\n";
    }
}


#include <iostream>
#include <stdio.h>
#include <cstring>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <ctime>
#include <cassert>
#include <unordered_map>
#include <fstream>
#include <random>
#include <cstring>
#include <complex>
#include <bitset>

#define all(a) (a).begin(), (a).end()
#define pb push_back
#define sz(a) (int)(a).size()

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef long double ld;

const ld EPS = 1e-12;

int main() {
    // ifstream cin("input.txt");
    // ofstream cout("output.txt");
    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);

    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int n, m;
    cin >> n;
    ll l, v1, v2;
    cin >> l >> v1 >> v2;

    vector<ll> a(n);

    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

    ll len = (ll)l * v2;

    vector<pair<ll, int>> events;

    int cnt = 0;
    for (int i = 0; i < n; ++i) {
        if (a[i] * (v1 + v2) - len >= 0) {
            events.push_back({a[i] * (v1 + v2) - len, 1});
            events.push_back({a[i] * (v1 + v2), -1});
        } else {
            cnt += 1;
            events.push_back({(2 * l + a[i]) * (v1 + v2) - len, 1});
            events.push_back({a[i] * (v1 + v2), -1});
        }
    }
    events.push_back({2 * l * (v1 + v2), 0});

    sort(all(events));

    vector<ll> res(n + 1);

    ll tm = 0;
    for (int i = 0; i < sz(events); ++i) {
        // cout << events[i].first << " " << events[i].second << endl;
        if (0 <= cnt && cnt <= n) {
            res[cnt] += events[i].first - tm;
        }
        tm = events[i].first;
        cnt += events[i].second;
    }

    cout.precision(12);
    cout << fixed;
    ll d = 2 * l * (v1 + v2);
    for (int i = 0; i <= n; ++i) {
        cout << (ld)res[i] / d << "\n";
    }
}


#include <iostream>
#include <stdio.h>
#include <cstring>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <ctime>
#include <cassert>
#include <unordered_map>
#include <fstream>
#include <random>
#include <cstring>
#include <complex>
#include <bitset>

#define all(a) (a).begin(), (a).end()
#define pb push_back
#define sz(a) (int)(a).size()

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef long double ld;

const ld EPS = 1e-12;

int main() {
    // ifstream cin("input.txt");
    // ofstream cout("output.txt");
    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);

    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int n, m;
    cin >> n;
    int l, v1, v2;
    cin >> l >> v1 >> v2;

    vector<int> a(n);

    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

    ll len = (ll)l * v2;

    vector<pair<ll, int>> events;

    int cnt = 0;
    for (int i = 0; i < n; ++i) {
        if (a[i] * (v1 + v2) - len >= 0) {
            events.push_back({(ll)a[i] * (v1 + v2) - len, 1});
            events.push_back({(ll)a[i] * (v1 + v2), -1});
        } else {
            cnt += 1;
            events.push_back({(ll)(2 * l + a[i]) * (v1 + v2) - len, 1});
            events.push_back({(ll)a[i] * (v1 + v2), -1});
        }
    }
    events.push_back({(ll)2 * l * (v1 + v2), 0});

    sort(all(events));

    vector<ld> res(n + 1);

    ld tm = 0;
    for (int i = 0; i < sz(events); ++i) {
        // cout << events[i].first << " " << events[i].second << endl;
        if (0 <= cnt && cnt <= n) {
            res[cnt] += events[i].first - tm;
        }
        tm = events[i].first;
        cnt += events[i].second;
    }

    cout.precision(12);
    cout << fixed;
    for (int i = 0; i <= n; ++i) {
        res[i] /= (ll)2 * l * (v1 + v2);
        cout << res[i] << "\n";
    }
}


#include <iostream>
#include <stdio.h>
#include <cstring>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <ctime>
#include <cassert>
#include <unordered_map>
#include <fstream>
#include <random>
#include <cstring>
#include <complex>
#include <bitset>

#define all(a) (a).begin(), (a).end()
#define pb push_back
#define sz(a) (int)(a).size()

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef long double ld;

const double EPS = 1e-9;

int main() {
    // ifstream cin("input.txt");
    // ofstream cout("output.txt");
    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);

    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int n, m;
    cin >> n;
    int l, v1, v2;
    cin >> l >> v1 >> v2;

    vector<int> a(n);

    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

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

    vector<pair<double, int>> events;

    int cnt = 0;
    for (int i = 0; i < n; ++i) {
        if (a[i] - len > 0) {
            events.push_back({a[i] - len, 1});
            events.push_back({a[i], -1});
        } else {
            cnt += 1;
            events.push_back({2 * l + a[i] - len, 1});
            events.push_back({a[i], -1});
        }
    }
    events.push_back({2 * l, 0});

    sort(all(events));

    vector<double> res(n + 1);

    double tm = 0;
    for (int i = 0; i < sz(events); ++i) {
        // cout << events[i].first << " " << events[i].second << endl;
        res[cnt] += events[i].first - tm;
        tm = events[i].first;
        cnt += events[i].second;
    }

    cout.precision(12);
    cout << fixed;
    for (int i = 0; i <= n; ++i) {
        res[i] /= 2 * l;
        cout << res[i] << "\n";
    }
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <string>
#include <set>
#include <map>
#include <algorithm>
#include <cmath>
#include <ctime>
#include <utility>
#include <cstdio>
#include <climits>

using namespace std;

const int size1 = 4e5;
const int INF = 1e9;
const long long mod = 1e9 + 7;
const long double pi  = 3.1415926;
long double eps = 1e-6;

int main()
{
#ifdef _DEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	long long n, l, v1, v2;
	cin >> n >> l >> v1 >> v2;
	static long long a[size1];
	vector < pair < double, int > > v;
	for (int i = 1; i <= n; i++)
	{
		cin >> a[i];
		long double l1 = (long double)(-a[i]) / v1;
		long double r1 = (((long double)v2) * l / (v1 + v2) - a[i]) / v1; \
			l1 *= v1;
		r1 *= v1;
		long long kol = trunc(-l1 / (2 * l));
		l1 += kol * 2 * l;
		r1 += kol * 2 * l;
		while (l1 < 0)
		{
			l1 += 2 * l;
			r1 += 2 * l;
		}
		v.push_back({ l1, 1});
		v.push_back({ r1, 2 });
		//cout << l1 << ' ' << r1 << endl;
	}
	sort(v.begin(), v.end());
	int cnt = 0;
	static long double ver[size1];
	ver[0] += v[0].first / (2 * l);
	//cout << ver[0] << endl;
	for (int i = 0; i < int(v.size() - 1); i++)
	{
		if (v[i].second == 1)
		{
			cnt++;
		}
		else
		{
			cnt--;
		}
		ver[cnt] += (v[i + 1].first - v[i].first) / (2 * l);
		//cout << ver[0] << endl;
	}
	ver[0] += (2 * l - v.back().first) / (2 * l);
	cout.precision(30);
	for (int i = 0; i <= n; i++)
	{
		cout << ver[i] << "\n";
	}
	return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <string>
#include <set>
#include <map>
#include <algorithm>
#include <cmath>
#include <ctime>
#include <utility>
#include <cstdio>
#include <climits>

using namespace std;

const int size1 = 4e5;
const int INF = 1e9;
const long long mod = 1e9 + 7;
const long double pi = 3.1415926;
long double eps = 1e-6;

int main()
{
#ifdef _DEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	long long n, l, v1, v2;
	cin >> n >> l >> v1 >> v2;
	static long long a[size1];
	vector < pair < double, int > > v;
	for (int i = 1; i <= n; i++)
	{
		cin >> a[i];
		long double l1 = (long double)(-a[i]) / v1;
		long double r1 = (((long double)v2) * l / (v1 + v2) - a[i]) / v1; \
			l1 *= v1;
		r1 *= v1;
		long long kol = trunc(-l1 / (2 * l));
		l1 += kol * 2 * l;
		r1 += kol * 2 * l;
		while (l1 < 0)
		{
			l1 += 2 * l;
			r1 += 2 * l;
		}
		v.push_back({ l1, 1});
		v.push_back({ r1, 2 });
		cout << l1 << ' ' << r1 << endl;
	}
	sort(v.begin(), v.end());
	int cnt = 0;
	static long double ver[size1];
	ver[0] += v[0].first / (2 * l);
	//cout << ver[0] << endl;
	for (int i = 0; i < int(v.size() - 1); i++)
	{
		if (v[i].second == 1)
		{
			cnt++;
		}
		else
		{
			cnt--;
		}
		ver[cnt] += (v[i + 1].first - v[i].first) / (2 * l);
		//cout << ver[0] << endl;
	}
	ver[0] += (2 * l - v.back().first) / (2 * l);
	cout.precision(30);
	for (int i = 0; i <= n; i++)
	{
		cout << ver[i] << "\n";
	}
	return 0;
}


'''
def main():
	from sys import stdin,stdout
if __name__=='__main__':
	main()
'''
#349B
'''
def main():
	from sys import stdin,stdout
	N = int(stdin.readline())
	arr = list(map(int,stdin.readline().split()))
	div = []
	for i in arr:
		div.append(N//i)
	maxim = 0
	maxindex = -1
	for i in range(9):
		if div[i] >maxim:
			maxim = div[i]
			maxindex = i
	if maxindex > -1:
		ans = [ (maxindex+1) for i in range(maxim)]
		N= N%arr[maxindex]
		#print(N)
		i = 0
		while i<maxim:
			#print('i=',i,'N=',N)
			for j in range(8,maxindex,-1):
				#print('j=',j,'diff=',arr[j]-arr[ans[i]-1])
				if arr[j]-arr[ans[i]-1] <=N:
					N -= arr[j]-arr[ans[i]-1]
					ans[i] = j+1
					break
			i+=1
		for i in ans:
			stdout.write(str(i))
	else:
		stdout.write('-1\n')
if __name__=='__main__':
	main()
'''
#234B Input and Output
'''
def main():
	from sys import stdin,stdout
	import collections
	with open('input.txt','r') as ip:
		N,K = map(int,ip.readline().split())
		arr = list(map(int,ip.readline().split()))
	mydict = collections.defaultdict(set)
	for i in range(len(arr)):
		mydict[arr[i]].add(i+1)
	ans = []
	i=0
	while K>0:
		for it in mydict[sorted(mydict.keys(),reverse=True)[i]]:
			ans.append(it)
			K-=1
			if K<1:
				break
		minim=i
		i+=1
	with open('output.txt','w') as out:
		out.write(str(sorted(mydict.keys(),reverse=True)[minim])+'\n')
		ans=' '.join(str(x) for x in ans)
		out.write(ans+'\n')
if __name__=='__main__':
	main()
'''
#151B
'''
def main():
	from sys import stdin,stdout
	import collections
	names = collections.defaultdict(list)
	counter = 0
	order = {}
	for i in range(int(stdin.readline())):
		n,ns = stdin.readline().split()
		names[ns]=[0,0,0]
		order[ns]=counter
		counter+=1
		n=int(n)
		while n:
			ip=stdin.readline().strip()
			ip=ip.replace('-','')
			#test for taxi
			flag=True
			for i in range(1,6):
				if ip[i]!=ip[0]:
					flag=False
					break
			if flag:
				names[ns][0]+=1
				n-=1
				continue
			#test for pizza
			flag = True
			for i in range(1,6):
				if int(ip[i])>=int(ip[i-1]):
					flag =False
					break
			if flag:
				names[ns][1]+=1

			else:
				names[ns][2]+=1
			n-=1
	#print(names)
	#for all girls
	t=-1
	p=-1
	g=-1
	for i in names:
		t=max(t,names[i][0])
		p = max(p, names[i][1])
		g = max(g, names[i][2])

	taxi=list(filter(lambda x: names[x][0]==t, names.keys()))
	pizza = list(filter(lambda x: names[x][1] == p, names.keys()))
	girls = list(filter(lambda x: names[x][2] == g, names.keys()))

	pizza.sort(key= lambda x: order[x])
	taxi.sort(key= lambda x: order[x])
	girls.sort(key= lambda x: order[x])

	print('If you want to call a taxi, you should call:',', '.join(x for x in taxi),end='.\n')
	print('If you want to order a pizza, you should call:', ', '.join(x for x in pizza),end='.\n')
	print('If you want to go to a cafe with a wonderful girl, you should call:', ', '.join(x for x in girls),end='.\n')

if __name__=='__main__':
	main()
'''
#SQUADRUN Q2
'''
def LCMgen(a):
	import math
	lcm = a[0]
	for i in range(1,len(a)):
		g = math.gcd(lcm,a[i])
		lcm = (lcm*a[i])//g
	return lcm

def main():
	from sys import stdin,stdout
	import collections
	import math
	N,W = map(int,stdin.readline().split())
	counter = collections.Counter(map(int,stdin.readline().split()))
	lcm = LCMgen(list(counter.keys()))
	W*=lcm
	div = 0
	for i in counter:
		div+=counter[i]*(lcm//i)
	ans = math.ceil(W/div)
	stdout.write(str(ans))
if __name__=='__main__':
	main()
'''
#143B
def main():
    from sys import stdin,stdout
    ip = stdin.readline().strip()
    inte = None
    flow = None
    for i,j in enumerate(ip):
        if j=='.':
            flow = ip[i:]
            inte = ip[:i]
            break
    if flow == None:
        flow = '.00'
        inte = ip
    else:
        if len(flow)==2:
            flow+='0'
        else:
            flow = flow[:3]
    ne = False
    if ip[0]=='-':
        ne = True
    if ne:
        inte = inte[1:]
    inte = inte[::-1]
    ans =''
    for i,j in enumerate(inte):
        ans += j
        if i%3 == 2:
            ans+=','
    ans = ans[::-1]
    if ans[0]==',':
        ans = ans[1:0]
    ans = '$'+ans
    if ne:
        stdout.write('({})'.format(ans+flow))
    else:
        stdout.write(ans+flow)
if __name__=='__main__':
    main()


'''
def main():
	from sys import stdin,stdout
if __name__=='__main__':
	main()
'''
#349B
'''
def main():
	from sys import stdin,stdout
	N = int(stdin.readline())
	arr = list(map(int,stdin.readline().split()))
	div = []
	for i in arr:
		div.append(N//i)
	maxim = 0
	maxindex = -1
	for i in range(9):
		if div[i] >maxim:
			maxim = div[i]
			maxindex = i
	if maxindex > -1:
		ans = [ (maxindex+1) for i in range(maxim)]
		N= N%arr[maxindex]
		#print(N)
		i = 0
		while i<maxim:
			#print('i=',i,'N=',N)
			for j in range(8,maxindex,-1):
				#print('j=',j,'diff=',arr[j]-arr[ans[i]-1])
				if arr[j]-arr[ans[i]-1] <=N:
					N -= arr[j]-arr[ans[i]-1]
					ans[i] = j+1
					break
			i+=1
		for i in ans:
			stdout.write(str(i))
	else:
		stdout.write('-1\n')
if __name__=='__main__':
	main()
'''
#234B Input and Output
'''
def main():
	from sys import stdin,stdout
	import collections
	with open('input.txt','r') as ip:
		N,K = map(int,ip.readline().split())
		arr = list(map(int,ip.readline().split()))
	mydict = collections.defaultdict(set)
	for i in range(len(arr)):
		mydict[arr[i]].add(i+1)
	ans = []
	i=0
	while K>0:
		for it in mydict[sorted(mydict.keys(),reverse=True)[i]]:
			ans.append(it)
			K-=1
			if K<1:
				break
		minim=i
		i+=1
	with open('output.txt','w') as out:
		out.write(str(sorted(mydict.keys(),reverse=True)[minim])+'\n')
		ans=' '.join(str(x) for x in ans)
		out.write(ans+'\n')
if __name__=='__main__':
	main()
'''
#151B
'''
def main():
	from sys import stdin,stdout
	import collections
	names = collections.defaultdict(list)
	counter = 0
	order = {}
	for i in range(int(stdin.readline())):
		n,ns = stdin.readline().split()
		names[ns]=[0,0,0]
		order[ns]=counter
		counter+=1
		n=int(n)
		while n:
			ip=stdin.readline().strip()
			ip=ip.replace('-','')
			#test for taxi
			flag=True
			for i in range(1,6):
				if ip[i]!=ip[0]:
					flag=False
					break
			if flag:
				names[ns][0]+=1
				n-=1
				continue
			#test for pizza
			flag = True
			for i in range(1,6):
				if int(ip[i])>=int(ip[i-1]):
					flag =False
					break
			if flag:
				names[ns][1]+=1

			else:
				names[ns][2]+=1
			n-=1
	#print(names)
	#for all girls
	t=-1
	p=-1
	g=-1
	for i in names:
		t=max(t,names[i][0])
		p = max(p, names[i][1])
		g = max(g, names[i][2])

	taxi=list(filter(lambda x: names[x][0]==t, names.keys()))
	pizza = list(filter(lambda x: names[x][1] == p, names.keys()))
	girls = list(filter(lambda x: names[x][2] == g, names.keys()))

	pizza.sort(key= lambda x: order[x])
	taxi.sort(key= lambda x: order[x])
	girls.sort(key= lambda x: order[x])

	print('If you want to call a taxi, you should call:',', '.join(x for x in taxi),end='.\n')
	print('If you want to order a pizza, you should call:', ', '.join(x for x in pizza),end='.\n')
	print('If you want to go to a cafe with a wonderful girl, you should call:', ', '.join(x for x in girls),end='.\n')

if __name__=='__main__':
	main()
'''
#SQUADRUN Q2
'''
def LCMgen(a):
	import math
	lcm = a[0]
	for i in range(1,len(a)):
		g = math.gcd(lcm,a[i])
		lcm = (lcm*a[i])//g
	return lcm

def main():
	from sys import stdin,stdout
	import collections
	import math
	N,W = map(int,stdin.readline().split())
	counter = collections.Counter(map(int,stdin.readline().split()))
	lcm = LCMgen(list(counter.keys()))
	W*=lcm
	div = 0
	for i in counter:
		div+=counter[i]*(lcm//i)
	ans = math.ceil(W/div)
	stdout.write(str(ans))
if __name__=='__main__':
	main()
'''
#143B
def main():
    from sys import stdin,stdout
    ip = stdin.readline().strip()
    inte = None
    flow = None
    for i,j in enumerate(ip):
        if j=='.':
            flow = ip[i:]
            inte = ip[:i]
            break
    if flow == None:
        flow = '.00'
        inte = ip
    else:
        if len(flow)==2:
            flow+='0'
        else:
            flow = flow[:3]
    ne = False
    if ip[0]=='-':
        ne = True
    if ne:
        inte = inte[1:]
    inte = inte[::-1]
    ans =''
    for i,j in enumerate(inte):
        ans += j
        if i%3 == 2:
            ans+=','
    ans = ans[::-1]
    if ans[0]==',':
        ans = ans[1:]
    ans = '$'+ans
    if ne:
        stdout.write('({})'.format(ans+flow))
    else:
        stdout.write(ans+flow)
if __name__=='__main__':
    main()


"""
Brandt Smith, Lemuel Gorion and Peter Haddad

codeforces.com

Problem 143B
"""

n = input().rstrip('\n')

final = ''
temp = n.find('.')

if n[0] == '-':
    final = '(' + '${:,.2f}'.format(float(n[:temp + 3])) + ')'
else:
    final = '${:,.2f}'.format(float(n[:temp + 3]))

print(final)


"""
Brandt Smith, Lemuel Gorion and Peter Haddad

codeforces.com

Problem 143B
"""

n = input().rstrip('\n')

temp = n.find('.')

if temp == -1:
    n = n + '.00'
else:
    n = n + '00'

final = ''

for i in range(0, len(n)):
    if n[i] == '-':
        continue
    elif n[i] == '.':
        final = final + '.' + n[i + 1] + n[i + 2]
        break
    else:
        final = final + n[i]

final = '${:,d}'.format(int(final[:-3])) + final[len(final) - 3:]

if n[0] == '-':
    final = '(' + final + ')'

print(final)


"""
Brandt Smith, Lemuel Gorion and Peter Haddad

codeforces.com

Problem 143B
"""

import decimal
from decimal import ROUND_DOWN

decimal.getcontext().prec=2

n = input().rstrip('\n')

final = ''

if n[0] == '-':
    temp = n.find('.')

    if temp != -1:
        final = '(' + '${:,.2f}'.format(float(n[1:temp + 2])) + ')'
    else:
        final = '(' + '${:,.2f}'.format(float(n[1:])) + ')'
else:
    final = '${:,.2f}'.format(float(n))

print(final)


"""
Brandt Smith, Lemuel Gorion and Peter Haddad

codeforces.com

Problem 143B
"""

n = input().rstrip('\n')

final = ''

if n[0] == '-':
    temp = n.find('.')

    if temp != -1:
        final = '(' + '${:,.2f}'.format(float(n[1:temp + 2])) + ')'
    else:
        final = '(' + '${:,.2f}'.format(float(n[1:])) + ')'
else:
    final = '${:,.2f}'.format(float(n))

print(final)


"""
Brandt Smith, Lemuel Gorion and Peter Haddad

codeforces.com

Problem 143B
"""

n = input().rstrip('\n')

final = ''
temp = n.find('.')

if n[0] == '-':
    if temp != -1:
        final = '(' + '${:,.2f}'.format(float(n[1:temp + 3])) + ')'
    else:
        final = '(' + '${:,.2f}'.format(float(n[1:])) + ')'

else:
    if temp != -1:
        final = '${:,.2f}'.format(float(n[:temp + 3]))
    else:
        final = '${:,.2f}'.format(float(n))

print(final)


"""
Brandt Smith, Lemuel Gorion and Peter Haddad

codeforces.com

Problem 143B
"""

n = input().rstrip('\n')

final = ''
temp = n.find('.')

if n[0] == '-':
    if temp != -1:
        final = '(' + '${:,.2f}'.format(float(n[:temp + 3])) + ')'
    else:
        final = '(' + '${:,.2f}'.format(float(n)) + ')'

else:
    if temp != -1:
        final = '${:,.2f}'.format(float(n[:temp + 3]))
    else:
        final = '${:,.2f}'.format(float(n))

print(final)


"""
Brandt Smith, Lemuel Gorion and Peter Haddad

codeforces.com

Problem 143B
"""

n = input().rstrip('\n')

temp = n.find('.')

if temp == -1:
    n = n + '.00'
else:
    n = n + '00'

final = ''

for i in range(0, len(n)):
    if n[i] == '-':
        continue
    elif n[i] == '.':
        final = final + '.' + n[i + 1] + n[i + 2]
        break
    else:
        final = final + n[i]

print(final, float(final[:-3]))
final = '${:,d}'.format(int(final[:-3])) + final[len(final) - 3:]

if n[0] == '-':
    final = '(' + final + ')'

print(final)


n=input()
str2=''
str1=''
ind=0
flag=0
if '.' in n:
  flag=1
  ind=n.index('.')
  if len(n[ind+1:len(n)])==1:
    str2=str2+'.'+n[ind+1]+'0'
  elif len(n[ind+1:len(n)])>2:
    str2=str2+'.'+n[ind+1:ind+3]
  else:
    str2=str2+'.'+n[ind+1:len(n)]
if flag==1:
  i=ind-1
else:
  i=len(n)-1
  str2='.00'
count=3
flag=0
if n[0]=='-':
  flag=1
while i>=0 and n[i]!='-':
  if count==0:
    str1=','+str1
    count=3
  str1=n[i]+str1
  i=i-1
  count=count-1
if flag==1:
  print('($'+str1+str2+')')
else:
  print('$'+str1+str2)


n=input()
str2=''
str1=''
ind=0
flag=0
if '.' in n:
  flag=1
  ind=n.index('.')
  if len(n[ind+1:len(n)])==1:
    str2=str2+'.'+n[ind+1]+'0'
  elif len(n[ind+1:len(n)])>2:
    str2=str2+'.'+n[ind+1:ind+3]
  else:
    str2=str2+'.'+n[ind+1:len(n)]
if flag==1:
  i=ind-1
else:
  i=len(n)-1
count=3
flag=0
if n[0]=='-':
  flag=1
while i>=0 and n[i]!='-':
  if count==0:
    str1=','+str1
    count=3
  str1=n[i]+str1
  i=i-1
  count=count-1
if flag==1:
  print('($'+str1+str2+')')
else:
  print('$'+str1+str2)


s = input()
b = False
if s[0] == "-":
    s = s[1:]
    b = True
if "." in s:
    i,j = s.split(".")
    if len(j) > 2:
        j1 = j[:2]
    elif len(j) == 2:
        j1 = j
    elif len(j) == 1:
        j1 = j+"0"
    elif len(j) == 0:
        j1 = "00"
else:
    i = s
    j1 = "00"
li = []
for k in range(len(i)):
    li.append(s[k])
n = len(i) // 3
m = -3; p = 0
for i in range(n):
    li.insert(m-p,',')
    m = m-3
    p +=1
l1 =(''.join(map(str, li)))
if b:
    print("("+"$"+l1+"."+j1+")")
else:
    print("$"+l1+"."+j1)


s = input()
b = False
if s[0] == "-":
    s = s[1:]
    b = True
if "." in s:
    i,j = s.split(".")
    if len(j) > 2:
        j1 = j[:2]
    elif len(j) == 2:
        j1 = j
    elif len(j) == 1:
        j1 = j+"0"
    elif len(j) == 0:
        j1 = "00"
else:
    i = s
    j1 = "00"
li = []
for k in range(len(s)):
    li.append(s[k])
n = len(i) // 3
m = -3; p = 0
for i in range(n):
    li.insert(m-p,',')
    m = m-3
    p +=1
l1 =(''.join(map(str, li)))
if b:
    print("("+"$"+l1+"."+j1+")")
else:
    print("$"+l1+"."+j1)


import textwrap

money = list(input())

if money[0] == "-":
	negative = True
	money = "".join(money[1:])
else:
	negative = False
	money = "".join(money)

money = list(money.split("."))

if len(money) == 1:
    whole = money[0]
    partial = -1
else:
    whole = money[0]
    partial = list(money[1])

if partial != -1:
    if len(partial) < 2:
    	while len(partial) < 2:
    	    partial.append("0")
    	    partial = "".join(partial)
    elif len(str(partial)) > 2:
        partial = partial[:2]
        partial = "".join(partial)
else:
    partial = "00"

whole = list(whole)[::-1]
commas = 0
if len(whole)> 3:
    commas = len(whole) // 3

wole = []
for i in range(len(whole)):
    if i % 3 == 0 and i != 0:
        wole.append(",")
    wole.append(whole[i])

whole = wole[::-1]

if whole[0] == ",":
    whole = whole[1:]

whole = list(map(str, whole))
whole = "".join(whole)

final = "$" + whole + "." + partial

if negative:
    final = list(final)
    final.insert(0, "(")
    final.append(")")
    final = "".join(final)

print(final)


money = list(input())

if money[0] == "-":
	negative = True
	money = "".join(money[1:])
else:
	negative = False
	money = "".join(money)

money = list(money.split("."))

if len(money) == 1:
    whole = money[0]
    partial = -1
else:
    whole = money[0]
    partial = list(money[1])

if partial != -1:
    if len(partial) < 2:
    	while len(partial) < 2:
    	    partial.append("0")
    	    partial = "".join(partial)
    elif len(str(partial)) > 2:
        partial = partial[:2]
        partial = "".join(partial)
else:
    partial = "00"

whole = list(whole)[::-1]

if len(whole)> 3:
    for i in range(0, len(whole), 4):
    	whole.insert(3 + i, ",")

whole = whole[::-1]

if whole[0] == ",":
    whole = whole[1:]
whole = "".join(whole)

final = "$" + whole + "." + partial

if negative:
    final = list(final)
    final.insert(0, "(")
    final.append(")")
    final = "".join(final)

print(final)


money = list(input())

if money[0] == "-":
	negative = True
	money = "".join(money[1:])
else:
	negative = False
	money = "".join(money)

money = list(money.split("."))

if len(money) == 1:
    whole = money[0]
    partial = -1
else:
    whole = money[0]
    partial = list(money[1])

if partial != -1:
    if len(partial) < 2:
    	while len(partial) < 2:
    	    partial.append("0")
    	    partial = "".join(partial)
    elif len(str(partial)) > 2:
        partial = partial[:2]
        partial = "".join(partial)
else:
    partial = "00"

whole = list(whole)[::-1]

if len(whole)> 3:
    for i in range(0, len(whole), 4):
    	whole.insert(3 + i, ",")

whole = whole[::-1]
whole = "".join(whole)

final = "$" + whole + "." + partial

if negative:
    final = list(final)
    final.insert(0, "(")
    final.append(")")
    final = "".join(final)

print(final)


class Integer
  def to_currency()
    self.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\1,').reverse
  end
end

s = gets.chomp
sa = s.split(".")
if sa.length == 1
	sa << "00"
else
	sa[1] = sa[1].slice(0,2)
	if sa[1].length == 1
		sa[1] += "0"
	end
end
minus = false
if sa[0].slice(0,1) == "-"
	minus = true
end
sa[0] = sa[0].sub("-", "")
sa[0] = sa[0].to_i.to_currency
ret = "$" + sa.join(".")
if minus
	ret = "(" + ret + ")"
end
puts ret


t=gets.split[0]
minus=false
if t[0]=="-" then
        minus=true
        t=t.slice(1,t.length-1)
end
a,b=(t+'.0000.0').split('.')
res=""
a=a.to_i
b+="0000"
while a>0
        res=sprintf(",%03d",a%1000)+res;
        a/=1000
end
res=res.slice(1,res.length-1) if res[0]==','
res=res.slice(1,res.length-1) while res.size()>1 && res[0]=='0'
res="0" if res==""
res="$"+res+"."+b.slice(0,2)
res="("+res+")" if minus
puts res


#!/usr/bin/ruby
def read_int; gets.chomp.to_i; end
def read_ints; gets.chomp.split.map(&:to_i); end

a = gets.chomp
arr = a.split('')

minus = false
if arr[0] == '-'
  minus = true
  arr.shift
end

index = arr.index('.')
len = 0
if index == nil
  len = arr.size
else
  len = index
end

print '(' if minus
print '$'

count = (3 - (len % 3)) % 3

#puts "count = #{len}"

0.upto(len-1) do |i|
  print arr[i]
  count += 1
#  puts " count = #{count}"
  print ',' if len > 3 and count % 3 == 0 and i+1 != len
end

print '.'

len.times { arr.shift }
arr.shift if arr[0] == '.'

if arr.size == 0
  print '00'
elsif arr.size == 1
  print arr[0]
  print '0'
else
  print arr[0]
  print arr[1]
end

print ')' if minus
puts


n = gets.strip
m = false

if n[0] == "-"
  m = true
  n.delete! "-"
end

i,f = n.split(/\./)

f = "00" if f == nil
f += "0" if f.size == 1

s = i.size
a = "$"
i.each_char do |c|
  a += c
  s -= 1
  a += ","if s % 3 == 0 && s != 0
end
a += "."
a += f[0,2]

if m
  a = "(" + a
  a += ")"
end
puts a


n = gets.strip
m = false

p n
if n[0] == "-"
  m = true
  n.delete! "-"
end

i,f = n.split(/\./)
p i
f = "00" if f == nil
f += "0" if f.size == 1

s = i.size
a = "$"
i.each_char do |c|
  a += c
  s -= 1
  a += ","if s % 3 == 0 && s != 0
end
a += "."
a += f[0,2]

if m
  a = "(" + a
  a += ")"
end
puts a


a,b = gets.split('.')

a = a.chomp
b = b.chomp if b != nil

last = "\n"
if a[0].chr == '-'
  print '('
  last = ")\n"
  a = a[1..-1]
end

print '$'

i = a.length % 3
first = true
count = 0
a.each_byte{|c|
  print ',' if !first && i == 0
  print c.chr
  i = (i+2) % 3
  first = false
  count += 1
}

if b == nil
  print '.00'
elsif b.length == 1
  print ".#{b}0"
else
  print ".#{b[0..1]}"
end

print last


#!/usr/bin/ruby
include Math
require 'pp'
minus = false
input = gets.chomp
minus = true if input[0] == '-'
input.delete!('-')
if(input.include? '.')
  input = input.split ('.')
  input[1] = input[1][0..1]
else
  input = [input,'00']
end
input[0].reverse!
output = []
input[0].chars.to_a.each_with_index do |c,i|
  if output[i/3]
    output[i/3] += c
  else
    output[i/3] = c
  end
end
output = output.reverse.map{ |x| x.reverse!}.join(',')
output = '$'+output+'.'+input[1]
output += '0' if input[1].size < 2
output = '(' + output + ')' if minus
puts output


number = gets.chomp
integer = nil
fraction = nil

case number
  when /\A([^\.]+)\.(\d+)\Z/
  integer = $1
  fraction = $2
  when /\A([^\.]+)\Z/
  integer = $1
end

minus = false
minus = true if /\A\-/=~ integer
integer.gsub!( /\A\-/, "" )
if integer.size > 3
  integer = integer.reverse.gsub( /\d\d\d/, '\&,' ).reverse
end

if fraction.nil?
  fraction = "00"
end
if fraction.size < 2
  fraction += "0"
end
fraction = fraction.split(//)[0..1].join("")

if minus
  puts "($#{ integer }.#{ fraction })"
else
  puts "$#{ integer }.#{ fraction }"
end


number = gets.chomp
integer = nil
fraction = nil

if /\A([^\.]+)\.(\d+)\Z/=~ number
  integer = $1
  fraction = $2
elsif /\A([^\.]+)\Z/=~ number
  integer = $1
else
  raise
end

minus = false
minus = true if /\A\-/=~ integer
integer.gsub!( /\A\-/, "" )
if integer.size > 3
  integer = integer.reverse.gsub( /\d\d\d/, '\&,' ).reverse
end

if fraction.nil?
  fraction = "00"
end
if fraction.size < 2
  fraction += "0"
end
fraction = fraction.split(//)[0..1].join("")

if minus
  puts "($#{ integer }.#{ fraction })"
else
  puts "$#{ integer }.#{ fraction }"
end


number = gets.chomp
integer = nil
fraction = nil

case number
  when /\A([^\.]+)\.(\d+)\Z/
  integer = $1
  fraction = $2
  when /\A([^\.]+)\Z/
  integer = $1
end

minus = false
minus = true if /\A\-/=~ integer
integer.gsub!( /\A\-/, "" )
integer = integer.reverse.gsub( /\d\d\d/, '\&,' ).reverse

if fraction.nil?
  fraction = "00"
end
if fraction.size < 2
  fraction += "0"
end
fraction = fraction.split(//)[0..1].join("")

if minus
  puts "($#{ integer }.#{ fraction })"
else
  puts "$#{ integer }.#{ fraction }"
end

# p minus
# p integer
# p fraction


number = gets.chomp
integer = nil
fraction = nil

if /\A([^\.]+)\.(\d+)\Z/=~ number
  integer = $1
  fraction = $2
elsif /\A([^\.]+)\Z/=~ number
  integer = $1
else
  raise
end

minus = false
minus = true if /\A\-/=~ integer
integer.gsub!( /\A\-/, "" )
integer = integer.reverse.gsub( /\d\d\d/, '\&,' ).reverse
integer.gsub!( /\A,/, "" )

if fraction.nil?
  fraction = "00"
end
if fraction.size < 2
  fraction += "0"
end
fraction = fraction.split(//)[0..1].join("")

if minus
  puts "($#{ integer }.#{ fraction })"
else
  puts "$#{ integer }.#{ fraction }"
end


n = gets.chomp
a,b = n.gsub("-","").split(".")
b = b || "0"
b = b[0..1].ljust(2,"0")
a = a.reverse.scan(/.{1,3}/).map(&:reverse).reverse.join(",")

number = "#{a}.#{b}"

if n[0] != "-"
	puts "$#{number}"
else
	puts "($#{number})"
end


s = gets.strip
if s[/\./]
  s += '00'
else
  s += '.00'
end
if s.match(/\A(-)?([\d]+)\.(\d\d)/)
  sign, main, sub = $1, $2, $3
  main = (main.reverse.scan(/.{1,3}/)*",").reverse
  if sign
    puts "($#{main}.#{sub})"
  else
    puts "$#{main}.#{sub}"
  end

end


n = gets.strip
m = false

if(n[0] == '-')
    m = true
    n.delete! '-'
end

i, f = n.split(/\./)

if(f == nil)
    f = "00";
end

if(f.size == 1)
    f += '0'
end

ans = '$'
siz = i.size

i.each_char do
    |c|
    siz -= 1;
    ans += c;

    if(siz % 3 == 0 and siz != 0)
        ans += ','
    end
    #puts(ans)
end

ans += '.'
ans += f[0,2]

if(m)
    print("(", ans, ")")
end

if(!m)
    print(ans)
end


n = gets.strip
m = false

if(n[0] == '-')
    m = true
    n.delete! '-'
end

i, f = n.split(/\./)

if(f == nil)
    f = "00";
end

if(f.size == 1)
    f += '0'
end

ans = '$'
siz = i.size

i.each_char do
    |c|
    siz -= 1;
    ans += c;

    if(siz % 3 == 0 and siz != 0)
        ans += ','
    end
    #puts(ans)
end

ans += '.'
ans += f[0..2]

if(m)
    print("(", ans, ")")
end

if(!m)
    print(ans)
end


input = gets.strip
surround = input[0] == "-" ? (input[0] = ""; true) : false

input = input.split '.'
l = []

input[0].split('').reverse.each_slice(3) { |s| l << s.reverse.join + "," }
l = l.reverse.join.chop

r = input[1]
r = "00"    if r.nil?
r = r + "0" if r.length == 1
r = r[0, 2] if r.length >= 2

print '(' if surround
print '$', l, '.', r
print ')' if surround


inp = raw_input()
ans = []
if inp[0] == '-':
    ans.extend(')')
    inp = inp[1:]

L = list(inp)
if '.' not in L:
    L.extend('.00')
L.extend('00')
ind = L.index('.')
frac = L[ind:][:3]
ans.extend(reversed(frac))
inte = L[0:ind]
while inte:
    ans.extend(reversed(inte[-3:]))
    ans.extend(',')
    inte = inte[0:-3]
ans = ans[:-1]
ans.extend('$')
if ans[0] == ')': ans.extend('(')
ans.reverse()
print ''.join(ans)


num = raw_input().strip().split(".")
front = abs(int(num[0]))
neg = (num[0][0] == '-')

if len(num) == 1:
  back = "00"
else:
  if front == 0 and int(num[1]) == 0: neg = False
  back = num[1][:2]
  back += "0"*(2-len(back))

def ff(num):
  digs = []
  i = 0
  for c in reversed(str(num)):
    if i > 0 and i % 3 == 0:
      digs.append(",")
    digs.append(c)
    i += 1
  return "".join(reversed(digs))

if neg:
  print "($%s.%s)" % (ff(front), back)
else:
  print "$%s.%s" % (ff(front), back)


import math
from fractions import gcd
def inp():
    return int(raw_input())
def linp():
    return map(int, raw_input().split())
s = list(raw_input())
flag = 0
if s[0]=='-':
    flag = 1
s.append('.')
ind = s.index('.')
num = []
temp = 0
for i in xrange(ind-1, -1, -1):
    if s[i]=='-':
        continue
    num.append(s[i])
    temp+=1
    if temp==3:
        num.append(',')
        temp = 0
num.append('$')
fr = []
num = num[::-1]
l = len(s)
for i in xrange(ind+1, ind+3):
    if i>=l or s[i]=='.':
        fr.append('0')
    else:
        fr.append(s[i])
if flag==0:
    print ''.join(num)+"."+''.join(fr)
else:
    print "("+''.join(num)+"."+''.join(fr)+")"


import math
from fractions import gcd
def inp():
    return int(raw_input())
def linp():
    return map(int, raw_input().split())
s = list(raw_input())
flag = 0
if s[0]=='-':
    flag = 1
s.append('.')
ind = s.index('.')
num = []
temp = 0
for i in xrange(ind-1, -1, -1):
    if s[i]=='-':
        continue
    if temp==3:
        num.append(',')
        temp=0
    num.append(s[i])
    temp+=1
num.append('$')
fr = []
num = num[::-1]
l = len(s)
for i in xrange(ind+1, ind+3):
    if i>=l or s[i]=='.':
        fr.append('0')
    else:
        fr.append(s[i])
if flag==0:
    print ''.join(num)+"."+''.join(fr)
else:
    print "("+''.join(num)+"."+''.join(fr)+")"


import re;

line = raw_input();
line = re.split('(\.)', line);

if len(line)==3:
    if len(line[2])<2:
        line[2] = line[2] + "0";
    else:
        line[2] = int(line[2])/pow(10,len(line[2])-2); #truncating fractional part

if line[0][0]=='-':
    negative = True;
    line[0] = line[0][1:];
else:
    negative = False;

num = line[0][::-1];
num = re.split ('(\d\d\d)', num);
num = [value for value in num if value != '']

ret = "";
if negative==True:
    ret = ret+"(";

ret = ret+"$";

for i in range (len(num)-1, 0, -1):
    ret = ret+num[i][::-1]+",";

ret = ret+num[0][::-1];

if len(line)==3:
    ret = ret+".";
    ret = ret+str(line[2]);

if negative==True:
    ret = ret+")";

print ret;


import re;

line = raw_input();
line = re.split('(\.)', line);

if len(line)==3:
    if len(line[2])<2:
        line[2] = line[2] + "0";
    else:
        line[2] = line[2][:2]; #truncating fractional part

if line[0][0]=='-':
    negative = True;
    line[0] = line[0][1:];
else:
    negative = False;

num = line[0][::-1];
num = re.split ('(\d\d\d)', num);
num = [value for value in num if value != '']

ret = "";
if negative==True:
    ret = ret+"(";

ret = ret+"$";

for i in range (len(num)-1, 0, -1):
    ret = ret+num[i][::-1]+",";

ret = ret+num[0][::-1];

if len(line)==3:
    ret = ret+".";
    ret = ret+str(line[2]);
else:
    ret = ret +".00";

if negative==True:
    ret = ret+")";

print ret;


import re;

line = raw_input();
line = re.split('(\.)', line);

if len(line)==3:
    if len(line[2])<2:
        line[2] = line[2] + "0";
    else:
        line[2] = int(line[2])/pow(10,len(line[2])-2); #truncating fractional part

if line[0][0]=='-':
    negative = True;
    line[0] = line[0][1:];
else:
    negative = False;

num = line[0][::-1];
num = re.split ('(\d\d\d)', num);
num = [value for value in num if value != '']

ret = "";
if negative==True:
    ret = ret+"(";

ret = ret+"$";

for i in range (len(num)-1, 0, -1):
    ret = ret+num[i][::-1]+",";

ret = ret+num[0][::-1];

if len(line)==3:
    ret = ret+".";
    ret = ret+str(line[2]);
else:
    ret = ret +".00";

if negative==True:
    ret = ret+")";

print ret;


import re

s = raw_input()
sgn = 1
if s[0] == '-':
      sgn = -1
      s = s[1:]
integer, decimal = '', ''
if s.find('.') > 0:
      integer = s[:s.find('.')]
      decimal = s[s.find('.') + 1:]
      if len(decimal) > 2:
            decimal = decimal[:2]
      if len(decimal) < 2:
            decimal = decimal + '0'
else:
      integer = s
      decimal = '00'
integer = re.sub('(\d\d\d)', '\\1,', integer[::-1])[::-1]
if integer[0] == ',': integer = integer[1:]
s = '$' + integer + '.' + decimal
if sgn == -1:
      s = '(' + s + ')'
print s


import re

s = raw_input()
sgn = 1
if s[0] == '-':
	  sgn = -1
	  s = s[1:]
integer, decimal = s, '00'
if '.' in s:
	integer, decimal = s.split('.')
	decimal = decimal[:2]
	if len(decimal) == 1: decimal += '0'
integer = re.sub('(\d\d\d)', '\\1,', integer[::-1])[::-1]
if integer[0] == ',': integer = integer[1:]
s = '$' + integer + '.' + decimal
if sgn == -1:
	  s = '(' + s + ')'
print s


ch = raw_input('')

dl = len(ch)

sp = []

if ch[0] != '-':
    m = 0
else:
    m = 1

for x in range(m,dl):
    sp.append(ch[x])

dl = dl - m

x = ch.find('.') - m

if x > -1:
    if dl >= x+3:
        del sp[x+3:]
    else:
        sp.append('0')

    x = x - 3
else:
    x = dl - 3

    sp.append('.')
    sp.append('0')
    sp.append('0')

while x > 0:
    sp.insert(x,',')

    x = x - 3

if m == 1:
    sp.insert(0,'(')
    sp.insert(1,'$')
    sp.append(')')
else:
    sp.insert(0,'$')

vyv = ''
vyv = vyv.join(sp)

print vyv


ch = raw_input('')

dl = len(ch)

sp = []

if ch[0] != '-':
    m = 0
else:
    m = 1

for x in range(m,dl):
    sp.append(ch[x])

dl = dl - m

if sp.count('.') == 1:
    x = sp.index('.')

    if dl >= x+3:
        del sp[x+3:]
    else:
        sp.append('0')

    x = x - 3
else:
    x = dl - 3

    sp.append('.')
    sp.append('0')
    sp.append('0')

while x > 0:
    sp.insert(x,',')

    x = x - 3

if sp[0] == '0' and sp[2] == '0' and sp[3] == '0':
    m = 0

if m == 1:
    sp.insert(0,'(')
    sp.insert(1,'$')
    sp.append(')')
else:
    sp.insert(0,'$')

vyv = ''
vyv = vyv.join(sp)

print vyv


ch = raw_input('')

dl = len(ch)

sp = []

if ch[0] != '-':
    m = 0
else:
    m = 1

for x in range(m,dl):
    sp.append(ch[x])

dl = dl - m

if sp.count('.') == 1:
    x = sp.index('.')

    if dl >= x+3:
        del sp[x+3:]
    else:
        sp.append('0')

    x = x - 3
else:
    x = dl - 3

    sp.append('.')
    sp.append('0')
    sp.append('0')

while x > 0:
    sp.insert(x,',')

    x = x - 3

if m == 1:
    sp.insert(0,'(')
    sp.insert(1,'$')
    sp.append(')')
else:
    sp.insert(0,'$')

vyv = ''
vyv = vyv.join(sp)

print vyv


#!/usr/bin/env python

nr = raw_input().strip()

parts = nr.split('.')
integer = parts[0]

fraction = ""
if len(parts) == 2:
  fraction = parts[1]
  if len(fraction) > 2:
    fraction = fraction[0:2]

while len(fraction) < 2:
  fraction += "0"

negative = (integer[0] == '-')
if negative:
  integer = integer[1:]

integer_parts = []
while len(integer) > 0:
  integer_parts.append(integer[-3:])
  integer = integer[:-3]

integer = ",".join(reversed(integer_parts))

if negative:
  print "($%s.%s)" % (integer, fraction)
else:
  print "$%s.%s" % (integer, fraction)


import math

def b(string):
  if string.find(".") == -1:
    string = string + ".00"
  integral_s, decimal_s = string.split('.')
  integral = int(integral_s)
  if len(decimal_s) == 1:
    decimal = 10 * int(decimal_s)
  else:
    decimal = int(decimal_s[:2])

  negative = False
  if integral_s[0] == '-':
    negative = True
    integral = -integral
    integral_s = integral_s[1:]

  ss = []
  integral_s = ''.join(list(reversed(integral_s)))
  for x in xrange(0, len(integral_s), 3):
    ss.append(''.join(reversed(integral_s[x:x+3])))

  s = "$%s.%.02d" % (','.join(reversed(ss)), decimal)
  if negative:
    s = "(" + s + ")"
  return s

"""
print b("2012.04")
print b("-2012.100")
print b("0.000")
print b("-0.00987654321")
print b("-12345678.9")
print b("0.99999999999999999999")
"""
print b(raw_input())
#"""


import math

def b(string):
  if string.find(".") == -1:
    string = string + ".00"
  integral_s, decimal_s = string.split('.')
  integral = int(integral_s)
  decimal = int(decimal_s[:2])
  if decimal < 10:
    decimal *= 10

  negative = False
  if integral_s[0] == '-':
    negative = True
    integral = -integral
    integral_s = integral_s[1:]

  ss = []
  integral_s = ''.join(list(reversed(integral_s)))
  for x in xrange(0, len(integral_s), 3):
    ss.append(''.join(reversed(integral_s[x:x+3])))

  s = "$%s.%.02d" % (','.join(reversed(ss)), decimal)
  if negative:
    s = "(" + s + ")"
  return s

"""
print b("2012.0")
print b("-2012.100")
print b("0.000")
print b("-0.00987654321")
print b("-12345678.9")
"""
print b(raw_input())
#"""


import math

def b(string):
  if string.find(".") == -1:
    string = string + ".00"
  integral_s, decimal_s = string.split('.')
  integral = int(integral_s)
  if len(decimal_s) == 1:
    decimal = 10 * int(decimal_s)
  else:
    decimal = int(decimal_s[:2])

  negative = False
  if integral_s[0] == '-':
    negative = True
    integral = -integral
    integral_s = integral_s[1:]

  ss = []
  integral_s = ''.join(list(reversed(integral_s)))
  for x in xrange(0, len(integral_s), 3):
    ss.append(''.join(reversed(integral_s[x:x+3])))

  s = "$%s.%.02d" % (','.join(reversed(ss)), decimal)
  if negative:
    s = "(" + s + ")"
  return s

#"""
print b("2012.04")
print b("-2012.100")
print b("0.000")
print b("-0.00987654321")
print b("-12345678.9")
print b("0.99999999999999999999")
"""
print b(raw_input())
#"""


import math

def b(string):
  if string.find(".") == -1:
    string = string + ".00"
  integral_s, decimal_s = string.split('.')
  integral = int(integral_s)
  if len(decimal_s) == 1:
    decimal = 10 * int(decimal_s)
  else:
    decimal = 10 * int(decimal_s[:2])

  negative = False
  if integral_s[0] == '-':
    negative = True
    integral = -integral
    integral_s = integral_s[1:]

  ss = []
  integral_s = ''.join(list(reversed(integral_s)))
  for x in xrange(0, len(integral_s), 3):
    ss.append(''.join(reversed(integral_s[x:x+3])))

  s = "$%s.%.02d" % (','.join(reversed(ss)), decimal)
  if negative:
    s = "(" + s + ")"
  return s

"""
print b("2012.04")
print b("-2012.100")
print b("0.000")
print b("-0.00987654321")
print b("-12345678.9")
"""
print b(raw_input())
#"""


import math

def b(string):
  if string.find(".") == -1:
    string = string + ".00"
  integral_s, decimal_s = string.split('.')
  integral = int(integral_s)
  decimal = int(decimal_s)

  negative = False
  if integral_s[0] == '-':
    negative = True
    integral = -integral
    integral_s = integral_s[1:]

  ss = []
  integral_s = ''.join(list(reversed(integral_s)))
  for x in xrange(0, len(integral_s), 3):
    ss.append(''.join(reversed(integral_s[x:x+3])))

  s = "$%s.%.02d" % (','.join(reversed(ss)), decimal)
  if negative:
    s = "(" + s + ")"
  return s

"""
print b("2012.04")
print b("-2012.100")
print b("0.000")
print b("-0.00987654321")
print b("-12345678.9")
"""
print b(raw_input())
#"""


import math

def b(string):
  if string.find(".") == -1:
    string = string + ".00"
  integral_s, decimal_s = string.split('.')
  integral = int(integral_s)
  decimal = int(decimal_s)

  negative = False
  if integral_s[0] == '-':
    negative = True
    integral = -integral
    integral_s = integral_s[1:]

  ss = []
  integral_s = ''.join(list(reversed(integral_s)))
  for x in xrange(0, len(integral_s), 3):
    ss.append(''.join(reversed(integral_s[x:x+3])))

  s = "$%s.%.02d" % (','.join(reversed(ss)), decimal)
  if negative:
    s = "(" + s + ")"
  return s

#"""
print b("2012.04")
print b("-2012.100")
print b("0.000")
print b("-0.00987654321")
print b("-12345678.9")
"""
print b(raw_input())
#"""


import math

def b(string):
  if string.find(".") == -1:
    string = string + ".00"
  integral_s, decimal_s = string.split('.')
  integral = int(integral_s)
  decimal = int(decimal_s[:2])

  negative = False
  if integral_s[0] == '-':
    negative = True
    integral = -integral
    integral_s = integral_s[1:]

  ss = []
  integral_s = ''.join(list(reversed(integral_s)))
  for x in xrange(0, len(integral_s), 3):
    ss.append(''.join(reversed(integral_s[x:x+3])))

  s = "$%s.%.02d" % (','.join(reversed(ss)), decimal)
  if negative:
    s = "(" + s + ")"
  return s

"""
print b("2012.04")
print b("-2012.100")
print b("0.000")
print b("-0.00987654321")
print b("-12345678.9")
"""
print b(raw_input())
#"""


import sys
import math
import itertools

def convert_to_financial(s):
  if len(s) >= 2:
    return s[:2]
  else:
    return s + (2 - len(s)) * '0'

def add_comma(s, sep = ','):
  out = ''
  while len(s) > 3:
    out = sep + s[-3:] + out
    s = s[:-3]
  return s + out

if __name__ == '__main__':
  s = raw_input().rstrip()
  is_minus = False

  if s[0] == '-':
    is_minus = True
    s = s[1:]

  split = s.split(".")
  integer = None
  financial = None

  if len(split) == 2:
    integer = split[0]
    financial = split[1]
  else:
    integer = s
    financial = ""

  integer = add_comma(integer)
  financial = convert_to_financial(financial)

  if not is_minus:
    print "$%s.%s" % (integer, financial)
  else:
    print "($%s.%s)" % (integer, financial)


s = raw_input()
p = s.find(".")
ans = ""
if p == -1:
    ans = ".00"
    p = len(s)-1
else:
    s += "00"
    ans = s[p:p+3]
    p -= 1
cnt = 0
while p >= 0 and s[p] != "-":
    if cnt > 0 and cnt % 3 == 0:
        ans = "," + ans
    ans = s[p] + ans
    p -= 1
    cnt += 1
if s[0] == "-":
    ans = "($" + ans + ")"
else:
    ans = "$" + ans
print ans


import sys

dec,fr = (sys.stdin.readline().strip('\n\r ').split('.') + ['00'])[:2]
fr = (fr+'00')[:2]
if dec[:1]=='-':
  ps='()'
  dec=dec[1:]
else:
  ps=''

if len(dec)==0: dec='0'

groups=[]
while dec:
  groups += [ dec[-3:] ]
  dec = dec[:-3]

groups.reverse()

print( ps[:1] + '$' + ','.join(groups) + '.' + fr + ps[-1:])


import sys

s = sys.stdin.readline().strip()

flag = 0
if s[0] == "-":
    s = s[1:]
    flag = 1
integer = ""
frac = ""
if "." in s:
    lst = s.split(".")
    integer = lst[0]
    frac = lst[1]
else:
    integer = s
#print integer, frac, s
resin = ""
for c, i in enumerate(xrange(len(integer))):
#    print c, i
    resin = integer[len(integer)-i-1] + resin
    if c % 3 == 2 and i != len(integer)-1:
        resin = "," + resin
#print resin
resin += "."
if len(frac) == 0:
    resin += "00"
elif  len(frac) == 1:
    resin += frac + "0"
else:
    resin += frac[0:2]
if flag:
    resin = "($" + resin + ")"
    print resin
else:
    print "$" + resin


if __name__ == "__main__":
    str = str(raw_input())
    str = str.split(".")
    main = str[0]
    if len(str) < 2:
        frac = "00"
    else:
    	frac = str[1][:2]
    	if len(frac) == 1:
    		frac += "0"
    	elif len(frac) == 0:
    		frac += "00"
    minus = False
    if main.startswith("-"):
    	main = main[1:]
    	minus = True

    main1 = ""
    main = main[::-1]
    for i in range(0, len(main), 3):
    	main1 += main[i:i+3] + ","
    main1 = main1[::-1].strip(",")

    if minus:
    	print "($" + main1 + "." + frac + ")"
    else:
    	print "$" + main1 + "." + frac


if __name__ == "__main__":
    str = str(input())
    str = str.split(".")
    main = str[0]
    if len(str) < 2:
        frac = "00"
    else:
    	frac = str[1][:2]
    	if len(frac) == 1:
    		frac += "0"
    	elif len(frac) == 0:
    		frac += "00"
    minus = False
    if main.startswith("-"):
    	main = main[1:]
    	minus = True

    main1 = ""
    main = main[::-1]
    for i in range(0, len(main), 3):
    	main1 += main[i:i+3] + ","
    main1 = main1[::-1].strip(",")

    if minus:
    	print "($" + main1 + "." + frac + ")"
    else:
    	print "$" + main1 + "." + frac


s = raw_input()

K = s.split('.')

num = K[0]

ind = True
if num[0] == '-':
    ind = False
    num = num[1:]
i = len(num) - 1
ans = ''
while i >= 3:
    ans = ',' + num[i - 2:i + 1] + ans
    i -= 3
ans = num[:i + 1] + ans

if len(K) == 1:
    ans += '.00'
else:
    num = K[1]
    if len(num) > 2:
        ans += '.' + num[:2]
    else:
        ans += '.' + num + '0' * (2 - len(num))
if not ind:
    ans = '($' + ans + ')'
else:
    ans = '$' + ans
print ans


s = raw_input().split('.')
if len(s)==1:
    intg = s[0]
    dcml = ''
else:
    intg = s[0]
    dcml = s[1]
minus = 0
if intg[0] == '-':
    intg = intg[1:]
    minus = 1
dcml = dcml[:2]
if len(dcml)<2:
    dcml += '0'*(2-len(dcml))

tmp = intg[:len(intg)%3]
for i in range(len(intg)%3,len(intg),3):
    tmp += ','+intg[i:i+3]
intg=tmp

ans = ''
if minus:
    ans += '('
ans += '$'+intg+'.'+dcml
if minus:
    ans += ')'
print ans


s = raw_input().split('.')
if len(s)==1:
    intg = s[0]
    dcml = ''
else:
    intg = s[0]
    dcml = s[1]
minus = 0
if intg[0] == '-':
    intg = intg[1:]
    minus = 1
dcml = dcml[:2]
if len(dcml)<2:
    dcml += '0'*(2-len(dcml))

tmp = intg[:len(intg)%3]
for i in range(len(intg)%3,len(intg),3):
    tmp += ','+intg[i:i+3]
if tmp[0] == ',':
    intg = tmp[1:]
else:
    intg = tmp

ans = ''
if minus:
    ans += '('
ans += '$'+intg+'.'+dcml
if minus:
    ans += ')'
print ans


n = raw_input()
n = [i for i in n]
#print n
minus = False
if n[0] == '-':
	minus = True
	n.remove('-')
x = n.count('.')
if x == 0:
	n.append('.')
	n.append('0')
	n.append('0')
x = n.index('.')
#print n
#print x
k = n[0:x][::-1]
s = []
i = 0
while i < len(k):
	s.append(k[i])
	if i%3 == 2 and i != len(k)-1:
		s.append(',')
	i += 1
n = s[::-1] + n[x:]

#print n

if x != 0:
	x = n.index('.')
x = n.index('.')
#print x
#print len(n)
if len(n) - x - 1 > 2 and x != 0:
	n = n[0:x+3]
elif len(n) - x == 2:
	n.append('0');
#print n
n.insert(0, '$')
if minus:
	n.insert(0, '(')
	n.append(')')
#print n
print ''.join(n)


import re
num = raw_input()
sign = 1
if num[0] == '-':
    sign = -1
    num = num[1:]
integer, decimal = '',''
if num.find('.') != -1:
    integer = num[0:num.find('.')]
    decimal = num[num.find('.') + 1:]
    if len(decimal) > 2:
        decimal = decimal[0:2]
    elif len(decimal) < 2:
        decimal = decimal + '0'
else:
    integer = num
    decimal = '00'
integer = re.sub(r'(\d\d\d)', r'\1,', integer[::-1])[::-1]
if integer[0] == ',':
    integer = integer[1:]
num = '$' + integer + '.' + decimal
if sign == -1:
    num = '(' + num + ')'
print num


a = raw_input()
neg = 0
if '-' in a:
	neg = 1
	a = a.strip('-')
al = a.split('.')
itg = al[0]
if '.' in a:
	dec = al[1]
	if len(dec) <= 2:
		dec = dec + (2-len(dec))*'0'
	else:
		dec = dec[0:2]
else:
	dec = "00"
it = len(itg) - 1
l = []
while it >= 0:
	l.append(itg[max(0,it-2):it+1])
	it = it - 3
l.reverse()
ans = '$' + ','.join(l) + '.' + dec
if neg:
	ans = '(' + ans + ')'
print ans


from __future__ import division
import sys
from collections import namedtuple #x=namedtuple('point','x y')
from math import *
from collections import deque, OrderedDict #append #popleft
from fractions import gcd
from copy import copy ,deepcopy
from collections import Counter #Counter(list)
import re #re.split("[^a-zA-Z]",text)
from decimal import Decimal
# from functools import lru_cache #@lru_cache(maxsize = None)
"""
#reduce(func,list)
#map(func,list)
#filter(func,list)
#xor=lambda x,y :x^y
#sign = lambda x: math.copysign(1, x)
#list.reverse()
#list.sort() list=sorted(list)
list.sort(key=operator.itemgetter(1,2))
#reverse word word[::-1]
#word.islower()
#word.lower() word.upper()
x = x1 if exp1 else x2
any([false,true])
all([true,false])
"a".isalpha()
"1".isdigit()
int(str,base)
"""

fin=sys.stdin ;fout=sys.stdout
# fin=open('../in','r') ; fout=open('../out','w')
def readline():
    return fin.readline().strip()
def readstrings():
    return fin.readline().strip().split(' ')
def writeline(value):
    fout.write(str(value))
    fout.write("\n")
def read_integers():
    return [int(x) for x in fin.readline().strip().split(' ')]
def read_integer():
    return int(fin.readline().strip())
def end():
    sys.exit()
def readbig():
    return [Decimal(x) for x in fin.readline().strip().split(' ')]
word=readline()
if "." not in word:
    word+=".0"

n=float(word)
sign="p"
if n<0:
    sign="n"
    n=n*-1
d,f=word.split(".")
r=[]
if sign=='n':
    r.append("(")
    n=n*-1
r.append("$")
f=f[0:2].ljust(2,"0")
d=d[::-1]
d=''.join([d[i:i+3]+"," for i in range(0,len(d),3)])
d=d[0:len(d)-1][::-1]
r.append(d+"."+f)
if sign=='n':
    r.append(")")
print ''.join(r)


from __future__ import division
import sys
from collections import namedtuple #x=namedtuple('point','x y')
from math import *
from collections import deque, OrderedDict #append #popleft
from fractions import gcd
from copy import copy ,deepcopy
from collections import Counter #Counter(list)
import re #re.split("[^a-zA-Z]",text)
from decimal import Decimal
# from functools import lru_cache #@lru_cache(maxsize = None)
"""
#reduce(func,list)
#map(func,list)
#filter(func,list)
#xor=lambda x,y :x^y
#sign = lambda x: math.copysign(1, x)
#list.reverse()
#list.sort() list=sorted(list)
list.sort(key=operator.itemgetter(1,2))
#reverse word word[::-1]
#word.islower()
#word.lower() word.upper()
x = x1 if exp1 else x2
any([false,true])
all([true,false])
"a".isalpha()
"1".isdigit()
int(str,base)
"""

fin=sys.stdin ;fout=sys.stdout
# fin=open('../in','r') ; fout=open('../out','w')
def readline():
    return fin.readline().strip()
def readstrings():
    return fin.readline().strip().split(' ')
def writeline(value):
    fout.write(str(value))
    fout.write("\n")
def read_integers():
    return [int(x) for x in fin.readline().strip().split(' ')]
def read_integer():
    return int(fin.readline().strip())
def end():
    sys.exit()
def readbig():
    return [Decimal(x) for x in fin.readline().strip().split(' ')]

n=float(fin.readline().strip())
sign="p"
if n<0:
    sign="n"
    n=n*-1
d,f=str(n).split(".")
r=[]
if sign=='n':
    r.append("(")
    n=n*-1
r.append("$")
f=f[0:2].ljust(2,"0")
d=d[::-1]
d=''.join([d[i:i+3]+"," for i in range(0,len(d),3)])
d=d[0:len(d)-1][::-1]
r.append(d+"."+f)
if sign=='n':
    r.append(")")
print ''.join(r)


from __future__ import division
import sys
from collections import namedtuple #x=namedtuple('point','x y')
from math import *
from collections import deque, OrderedDict #append #popleft
from fractions import gcd
from copy import copy ,deepcopy
from collections import Counter #Counter(list)
import re #re.split("[^a-zA-Z]",text)
from decimal import Decimal
# from functools import lru_cache #@lru_cache(maxsize = None)
"""
#reduce(func,list)
#map(func,list)
#filter(func,list)
#xor=lambda x,y :x^y
#sign = lambda x: math.copysign(1, x)
#list.reverse()
#list.sort() list=sorted(list)
list.sort(key=operator.itemgetter(1,2))
#reverse word word[::-1]
#word.islower()
#word.lower() word.upper()
x = x1 if exp1 else x2
any([false,true])
all([true,false])
"a".isalpha()
"1".isdigit()
int(str,base)
"""

fin=sys.stdin ;fout=sys.stdout
# fin=open('../in','r') ; fout=open('../out','w')
def readline():
    return fin.readline().strip()
def readstrings():
    return fin.readline().strip().split(' ')
def writeline(value):
    fout.write(str(value))
    fout.write("\n")
def read_integers():
    return [int(x) for x in fin.readline().strip().split(' ')]
def read_integer():
    return int(fin.readline().strip())
def end():
    sys.exit()
def readbig():
    return [Decimal(x) for x in fin.readline().strip().split(' ')]
word=readline()
sign="p"
if "." not in word:
    word+=".0"
if word[0]=="-":
    word=word[1::]
    sign="n"
d,f=word.split(".")
r=[]
if sign=='n':
    r.append("(")
r.append("$")
f=f[0:2].ljust(2,"0")
d=d[::-1]
d=''.join([d[i:i+3]+"," for i in range(0,len(d),3)])
d=d[0:len(d)-1][::-1]
r.append(d+"."+f)
if sign=='n':
    r.append(")")
print ''.join(r)


from __future__ import division
import sys
from collections import namedtuple #x=namedtuple('point','x y')
from math import *
from collections import deque, OrderedDict #append #popleft
from fractions import gcd
from copy import copy ,deepcopy
from collections import Counter #Counter(list)
import re #re.split("[^a-zA-Z]",text)
from decimal import Decimal
# from functools import lru_cache #@lru_cache(maxsize = None)
"""
#reduce(func,list)
#map(func,list)
#filter(func,list)
#xor=lambda x,y :x^y
#sign = lambda x: math.copysign(1, x)
#list.reverse()
#list.sort() list=sorted(list)
list.sort(key=operator.itemgetter(1,2))
#reverse word word[::-1]
#word.islower()
#word.lower() word.upper()
x = x1 if exp1 else x2
any([false,true])
all([true,false])
"a".isalpha()
"1".isdigit()
int(str,base)
"""

fin=sys.stdin ;fout=sys.stdout
# fin=open('../in','r') ; fout=open('../out','w')
def readline():
    return fin.readline().strip()
def readstrings():
    return fin.readline().strip().split(' ')
def writeline(value):
    fout.write(str(value))
    fout.write("\n")
def read_integers():
    return [int(x) for x in fin.readline().strip().split(' ')]
def read_integer():
    return int(fin.readline().strip())
def end():
    sys.exit()
def readbig():
    return [Decimal(x) for x in fin.readline().strip().split(' ')]

n=Decimal(fin.readline().strip())
sign="p"
if n<0:
    sign="n"
    n=n*-1
d,f=str(n).split(".")
r=[]
if sign=='n':
    r.append("(")
    n=n*-1
r.append("$")
f=f[0:2].ljust(2,"0")
d=d[::-1]
d=''.join([d[i:i+3]+"," for i in range(0,len(d),3)])
d=d[0:len(d)-1][::-1]
r.append(d+"."+f)
if sign=='n':
    r.append(")")
print ''.join(r)


from __future__ import division
import sys
from collections import namedtuple #x=namedtuple('point','x y')
from math import *
from collections import deque, OrderedDict #append #popleft
from fractions import gcd
from copy import copy ,deepcopy
from collections import Counter #Counter(list)
import re #re.split("[^a-zA-Z]",text)
from decimal import Decimal
# from functools import lru_cache #@lru_cache(maxsize = None)
"""
#reduce(func,list)
#map(func,list)
#filter(func,list)
#xor=lambda x,y :x^y
#sign = lambda x: math.copysign(1, x)
#list.reverse()
#list.sort() list=sorted(list)
list.sort(key=operator.itemgetter(1,2))
#reverse word word[::-1]
#word.islower()
#word.lower() word.upper()
x = x1 if exp1 else x2
any([false,true])
all([true,false])
"a".isalpha()
"1".isdigit()
int(str,base)
"""

fin=sys.stdin ;fout=sys.stdout
# fin=open('../in','r') ; fout=open('../out','w')
def readline():
    return fin.readline().strip()
def readstrings():
    return fin.readline().strip().split(' ')
def writeline(value):
    fout.write(str(value))
    fout.write("\n")
def read_integers():
    return [int(x) for x in fin.readline().strip().split(' ')]
def read_integer():
    return int(fin.readline().strip())
def end():
    sys.exit()
def readbig():
    return [Decimal(x) for x in fin.readline().strip().split(' ')]
word=readline()
if "." not in word:
    word+=".0"

n=float(word)
sign="p"
if n<0:
    sign="n"
    n=n*-1
d,f=str(n).split(".")
r=[]
if sign=='n':
    r.append("(")
    n=n*-1
r.append("$")
f=f[0:2].ljust(2,"0")
d=d[::-1]
d=''.join([d[i:i+3]+"," for i in range(0,len(d),3)])
d=d[0:len(d)-1][::-1]
r.append(d+"."+f)
if sign=='n':
    r.append(")")
print ''.join(r)