Problem: N people run a marathon. There are M resting places on the way. For each resting place, the i-th runner takes a break with probability P_i percent. When the i-th runner takes a break, he gets rest for T_i time.

The i-th runner runs at constant speed V_i, and the distance of the marathon is L.

You are requested to compute the probability for each runner to win the first place. If a runner arrives at the goal with another person at the same time, they are not considered to win the first place.



Input

A dataset is given in the following format:

N M L
P_1 T_1 V_1
P_2 T_2 V_2
...
P_N T_N V_N


The first line of a dataset contains three integers N (1 \leq N \leq 100), M (0 \leq M \leq 50) and L (1 \leq L \leq 100,000). N is the number of runners. M is the number of resting places. L is the distance of the marathon.

Each of the following N lines contains three integers P_i (0 \leq P_i \leq 100), T_i (0 \leq T_i \leq 100) and V_i (0 \leq V_i \leq 100) describing the i-th runner. P_i is the probability to take a break. T_i is the time of resting. V_i is the speed.

Output

For each runner, you should answer the probability of winning. The i-th line in the output should be the probability that the i-th runner wins the marathon. Each number in the output should not contain an error greater than 10^{-5}.

Examples

Input

2 2 50
30 50 1
30 50 2


Output

0.28770000
0.71230000


Input

2 1 100
100 100 10
0 100 1


Output

0.00000000
1.00000000


Input

3 1 100
50 1 1
50 1 1
50 1 1


Output

0.12500000
0.12500000
0.12500000


Input

2 2 50
30 0 1
30 50 2


Output

0.51000000
0.49000000

Solution (in CPP):

Solution:
/*
 * 2303.cc: Marathon Match
 */

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
 
using namespace std;

/* constant */

const int MAX_N = 100;
const int MAX_M = 50;

typedef long long ll;

/* typedef */

struct Stat {
  double t, p;
  int i, j;
  Stat() {}
  Stat(double _t, double _p, int _i, int _j): t(_t), p(_p), i(_i), j(_j) {}
  bool operator<(const Stat &s) const { return t < s.t; }
};

typedef vector<Stat> vs;

/* global variables */

ll combs[MAX_M + 1][MAX_M + 1];
Stat rs[MAX_N][MAX_M + 1];
double psums[MAX_N][MAX_M + 2], ans[MAX_N];
int cs[MAX_N];

/* subroutines */

/* main */

int main() {
  int n, m, l;
  cin >> n >> m >> l;

  for (int i = 0; i <= m; i++) {
    combs[i][0] = combs[i][i] = 1;
    for (int j = 1; j < i; j++)
      combs[i][j] = combs[i - 1][j - 1] + combs[i - 1][j];
  }

  vs allrs;
  
  for (int i = 0; i < n; i++) {
    int pi, ti, vi;
    cin >> pi >> ti >> vi;

    double p = (double)pi / 100;
    double t0 = (double)l / vi;
    for (int j = 0; j <= m; j++) {
      double tj = t0 + ti * j;
      double pj = combs[m][j] * pow(p, j) * pow(1.0 - p, m - j);
      rs[i][j] = Stat(tj, pj, i, j);
      allrs.push_back(rs[i][j]);
    }
    psums[i][m + 1] = 0.0;
    for (int j = m; j >= 0; j--) psums[i][j] = psums[i][j + 1] + rs[i][j].p;
    //printf("%d: %lf\n", i, psums[i][0]);
  }

  sort(allrs.begin(), allrs.end());
  int rn = allrs.size();

  for (int i = 0; i < n; i++) ans[i] = 0.0, cs[i] = 0;

  for (int i = 0; i < rn; i++) {
    Stat &r = allrs[i];
    double pp = r.p;

    for (int j = 0; j < n; j++)
      if (r.i != j) {
	int cj = cs[j];
	if (cj <= m && rs[j][cj].t == r.t) cj++;
	pp *= psums[j][cj];
      }

    ans[r.i] += pp;
    cs[r.i]++;
  }

  for (int i = 0; i < n; i++) printf("%.8lf\n", ans[i]);
  return 0;
}