// Original C++ solution (slower):
/*

 * Author:  xioumu

 * Created Time:  2012/10/8 15:34:52

 * File Name: d.cpp

 * solve: d.cpp

 */

#include<cstdio>

#include<cstring>

#include<cstdlib>

#include<cmath>

#include<algorithm>

#include<string>

#include<map>

#include<set>

#include<iostream>

#include<vector>

#include<queue>

using namespace std;

#define sz(v) ((int)(v).size())

#define rep(i, n) for (int i = 0; i < (n); ++i)

#define repf(i, a, b) for (int i = (a); i <= (b); ++i)

#define repd(i, a, b) for (int i = (a); i >= (b); --i)

#define clr(x) memset(x,0,sizeof(x))

#define clrs( x , y ) memset(x,y,sizeof(x))

#define out(x) printf(#x" %d\n", x)

typedef long long lint;

const int maxint = -1u>>1;

const double esp = 1e-13;

const int maxn = 100 + 10;

const int maxm = 50 + 10;

double p[maxn], t[maxn], v[maxn];

int n, m, L;

double con[maxm][maxm];

double pow_p[maxn][maxm], pow_np[maxn][maxm], f[maxn][maxm], sum[maxn][maxm];

double ans[maxn];

double times[maxn][maxm];

int zore[maxn];

int sgn(double x) {

    return (x > esp) - (x < -esp);

}

bool cmp(const double &a, const double &b) {

    return sgn(a - b) < 0;

}

void init() {

    rep (i, n) {

        scanf("%lf%lf%lf", &p[i], &t[i], &v[i]);

        p[i] /= 100;

        zore[i] = 0;

        if(sgn(v[i]) == 0) {

            zore[i] = 1;

        }

    }

    con[0][0] = 1;

    repf (i, 1, m) {

        con[i][0] = con[i][i] = 1;

        repf (j, 1, i - 1)

            con[i][j] = con[i - 1][j] + con[i - 1][j - 1];

    }

    

    rep (i, n) {

        if(zore[i]) continue;

        pow_p[i][0] = 1;

        pow_np[i][0] = 1;

        times[i][0] = L * 1.0 / v[i];

        repf (j, 1, m) {

            pow_p[i][j] = pow_p[i][j - 1] * p[i];

            pow_np[i][j] = pow_np[i][j - 1] * (1 - p[i]);

            times[i][j] = times[i][j - 1] + t[i];

        }

    }

    

    rep (i, n) {

        if(zore[i]) continue;

        sum[i][0] = f[i][0] = con[m][0] * pow_np[i][m] * pow_p[i][0];

        repf (j, 1, m) {

            f[i][j] = con[m][j] * pow_np[i][m - j] * pow_p[i][j];

            sum[i][j] = sum[i][j - 1] + f[i][j];

        }

    }

}

double gao(double lim, int w) {

    //int h = m + 1;

    if(zore[w]) return 1;

    int h = upper_bound(times[w], times[w] + m + 1, lim, cmp) - times[w];

    //rep (i, m + 1)

        //if(sgn(times[w][i] - lim) > 0) {

            //h = i;

            //break;

        //}

    //printf("%d %d %f %f %f %f\n", h, hh, lim, times[w][h], times[w][hh], 1 - sum[w][h - 1]);

    //out(h);

    if(h - 1 < 0)  return 1;

    else return 1 - sum[w][h - 1];

}

int main()  {

    int blank = 0;

    while( scanf("%d%d%d", &n, &m, &L) == 3) {

        //if(blank) printf("\n");

        init();

        //if(n == 1) {

            //printf("%.8f\n", 1.0);

            //continue;

        //}

        rep (i, n) {

            ans[i] = 0;

            if(!zore[i]) 

                repf (j, 0, m) {

                    double res = 1;

                    rep (k, n) {

                        if(k == i) continue;

                        res *= gao(times[i][j], k);

                        //if(i == 1) printf("%f %f %d\n", gao(times[i][j], k), times[i][j], k);

                    }

                    //printf("%f %f %d %d\n", res, f[i][j], i, j);

                    ans[i] += res * f[i][j];

                }

            printf("%.12f\n", ans[i]);

            //if(i != n - 1) printf("\n");

        }

        //blank = 1;

    }

    return 0;

}

// Optimized solution to the same problem (faster):
#include <cstdio>

#include <cstring>

#include <cmath>

#include <algorithm>

#include <vector>



using namespace std;



#define MAXN 110

#define INF 0x3f3f3f3f

#define PI acos(-1.0)

#define MAX(a,b) (a>b?a:b)

#define MIN(a,b) (a<b?a:b)

#define ABS(m) (m<0?-m:m)

typedef long long LL;



int n,m,l;

LL c[MAXN][MAXN];

int p[MAXN],t[MAXN],v[MAXN];



void Init()

{

    int i,j;

    scanf("%d%d%d",&n,&m,&l);

    for(i=1;i<=n;++i)

        scanf("%d%d%d",p+i,t+i,v+i);

    c[0][0]=1;

    for(i=1;i<=50;++i)

        for(j=1,c[i][0]=1;j<=i;++j)

            c[i][j]=c[i-1][j]+c[i-1][j-1];

}



long double C(long double P,int N,int M)

{

    int i; long double ans=c[N][M];

    for(i=1;i<=M;++i) ans*=P;

    for(;i<=N;++i) ans*=(1-P);

    return ans;

}



void Work()

{

    int i,j,k,x;

    long double ans,r1,r2;

    long double P[MAXN][2];

    LL t1,t2;

    for(i=1;i<=n;++i){

        for(ans=0,j=0;j<=m;++j){

            t1=l+1LL*j*t[i]*v[i];

            r1=C(p[i]/100.0,m,j);

            for(k=1;k<=n;++k){

                if(k==i) continue;

                for(x=1,P[0][0]=P[0][1]=1;x<=m;++x)

                    P[x][0]=P[x-1][0]*p[k]/100.0,P[x][1]=P[x-1][1]*(1-p[k]/100.0);

                for(x=r2=0,t2=l;x<=m&&t2*v[i]<=t1*v[k];t2+=1LL*t[k]*v[k],++x);

                for(r2=0;x<=m;++x) r2+=((long double)c[m][x])*P[x][0]*P[m-x][1];

                r1*=r2;

            }

            ans+=r1;

        }

        printf("%.12f\n",(double)ans);

    }

}



int main()

{

    Init();

    Work();

    return 0;

}

// Fastest known solution for this problem: