#include <vector>
#pragma GCC target ("avx2")
#pragma GCC optimize ("O3")
#pragma GCC optimize ("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;

template<typename T>
ostream_iterator<T> oit(const string &s = " "){ return ostream_iterator<T>(cout,s.c_str()); }
inline auto rep(int l, int r) { return views::iota(min(l, r), r); }
inline auto rep(int n) { return rep(0, n); }
inline auto rep1(int l, int r) { return rep(l, r + 1); }
inline auto rep1(int n) { return rep(1, n + 1); }
inline auto per(int l, int r) { return rep(l, r) | views::reverse; }
inline auto per(int n) { return per(0, n); }
inline auto per1(int l, int r) { return per(l, r + 1); }
inline auto per1(int n) { return per(1, n + 1); }
#define A(a) begin(a),end(a)
inline auto len = ranges::ssize;

struct chash {
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};
template<typename T, typename U> using pb_map = gp_hash_table<T, U, chash>;
template<typename T> using pb_set = gp_hash_table<T, null_type, chash>;
#define K first
#define V second

using ll = long long;
using ld = double;

using vi = vector<int>;
using vii = vector<vector<int>>;
typedef vector<ll> vll;
using pll = pair<ll,ll>;
using pii = pair<int,int>;

const int L = 17;

void run()
{
    int n,t; cin >> n >> t;
    vector<ld> ans(n);  
    vi rt(n),ct(n); vector<ld> p(n);

    for(int i : rep(n))
        cin >> rt[i] >> ct[i] >> p[i];

    // i need two sweep arrays, one for people who have just solved something, and one for people who are reading things
    vector<array<ld,L>> solved(t+1);
    vector<array<ld,1LL<<L>> sweep(t+1);
    vector< array<array<ld,1LL<<L>,L> > reading(t); //time,problem,mask

    sweep[0][(1<<n)-1] = 1; //everyone starts out ready to read something, having read nothing

    for(int i=0;i<=t;i++){ //simulate
        for(int j =0;j<n;j++) ans[j] += solved[i][j]; //update total solve distribution
        if(i==t) break;
        for(int j =0;j<n;j++){ //move the reading people over to the free group, update solved
            for(int msk=0;msk<(1<<n);msk++){ //loop over the problems ppl are reading
                if(ct[j]+i<=t) solved[i+ct[j]][j] += reading[i][j][msk] * p[j], sweep[i+ct[j]][msk] += reading[i][j][msk] * p[j];
                sweep[i][msk] += reading[i][j][msk] * (1.0-p[j]);
            }
        }

        for(int msk=0;msk<(1<<n);msk++){ //move the free people over to the reading group
            ld sm = 0,problem_cnt=0; for(int j =0;j<n;j++) 
                if((msk>>j)&1) sm+=ans[j],problem_cnt++;
            if(sm==0){
                for(int j=0;j<n;j++)
                    if( ((msk>>j)&1) and rt[j]+i<t) 
                        reading[rt[j]+i][j][msk ^ (1<<j)] += (1.0/problem_cnt)*(sweep[i][msk]); 
            }else{
                for(int j=0;j<n;j++)
                    if( ((msk>>j)&1) and rt[j]+i<t) 
                        reading[rt[j]+i][j][msk ^ (1<<j)] += (ans[j]/sm)*sweep[i][msk];
            } 
        }
    }

    ranges::copy(ans,oit<ld>("\n"));
}

int main()
{   
    //KING OF THE WORLD...... U.W.T.B
    cin.tie(0);
    ios_base::sync_with_stdio(false);
    cout << fixed << setprecision(10);
    run();
}