/* slightly faster; ignores some states */
#include <iostream>
#include <iomanip>
using namespace std ;
const int MAXN = 17 ;
const int MAXT = 100 ;
double dp[MAXT+1][1LL<<MAXN] ;
double ds[MAXT+1][MAXN+1] ;
double p[MAXN], solved[MAXN] ;
int r[MAXN], s[MAXN] ;
int n, maxtime ;
int main() {
   cout << setprecision(15) ;
   cin >> n >> maxtime ;
   for (int i=0; i<n; i++)
      cin >> r[i] >> s[i] >> p[i] ;
   for (int i=0; i<n; i++) {
      if (p[i] > 0) {
         if (r[i] + s[i] <= maxtime) {
            dp[r[i]+s[i]][1<<i] = p[i]/n ;
            ds[r[i]+s[i]][i] = p[i]/n ;
         }
      }
      if (p[i] < 1) {
         dp[r[i]][1<<i] = (1-p[i])/n ;
      }
   }
   double totsolves = 0 ;
   for (int t=0; t<=maxtime; t++) {
      for (int ps=0; ps<n; ps++) {
         solved[ps] += ds[t][ps] ;
         totsolves += ds[t][ps] ;
      }
      for (int bm=0; (bm>>n)==0; bm++) {
         if (dp[t][bm] == 0)
            continue ;
         double subd = 0 ;
         int unreadsolved = 0 ;
         int read = 0 ;
         for (int i=0; i<n; i++) {
            if ((bm >> i) & 1) {
               read++ ;
               subd += solved[i] ;
            } else if (solved[i] != 0) {
               unreadsolved++ ;
            }
         }
         double psum = dp[t][bm] ;
         for (int i=0; i<n; i++) {
            if ((bm >> i) & 1)
               continue ;
            for (int dosolve=0; dosolve<2; dosolve++) {
               double pm = (dosolve ? p[i] : 1-p[i]) ;
               if (pm == 0)
                  continue ;
               int t2 = t + r[i] + (dosolve ? s[i] : 0) ;
               if (t2 > maxtime)
                  continue ;
               double vv = 0 ;
               if (unreadsolved)
                  vv = psum * pm * solved[i] / (totsolves - subd) ;
               else
                  vv = psum * pm / (n - read) ;
               dp[t2][bm|(1<<i)] += vv ;
               if (dosolve)
                  ds[t2][i] += vv ;
            }
         }
      }
   }
   for (int i=0; i<n; i++)
      cout << solved[i] << endl ;
}