//
// Mateusz Pietrowcow
//
 
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
 
#define MOD 1000000007
#define INF 1000000000
#define INFL 1000000000000000000ULL
#define Tak cout << "TAK" << '\n'
#define Nie cout << "NIE" << '\n'
#define min3(x, y, z) min(x, min(y, z))
#define max3(x, y, z) max(x, max(y, z))
 
using namespace std;
 
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef pair<int,int> ii;
typedef pair<long long, long long> pll;
typedef pair<unsigned long long, unsigned long long> pull;

struct Node
{
    int parent;
    bool isMarked;
    list<int> children;
    list<int>::iterator pos;
    pair<ull,int> info;

    Node(pair<ull, int> _info)
    {
        info = _info;
        parent = -1;
        isMarked = false;
    }
};

const int N = 7e3 + 5, MAXDEGREE = 15;

struct fastpq
{
    vector<int> dg[MAXDEGREE];
    list<int> roots;
    Node *t[N];
    int minNode;

    fastpq()
    {
        minNode = N - 1;
        t[N - 1] = new Node({ULLONG_MAX, N - 1});
    }

    // done
    bool empty()
    {
        return roots.empty();
    }
    
    // done
    pair<ull, int> top()
    {
        return t[minNode]->info;
    }
    
    // done
    int Union(int a, int b)
    {
        if (t[a]->info.first <= t[b]->info.first && minNode != b)
        {
            t[b]->parent = a;
            t[a]->children.push_back(b);
            t[b]->pos = prev(t[a]->children.end());
            return a;
        }

        t[a]->parent = b;
        t[b]->children.push_back(a);
        t[a]->pos = prev(t[b]->children.end());
        return b;
    }

    // done
    void clean()
    {
        int newMin = N - 1;

        for (auto i : roots)
        {
            if (i == minNode) continue;

            dg[t[i]->children.size()].push_back(i);

            if (t[i]->info.first < t[newMin]->info.first)
                newMin = i;
        }
        minNode = newMin;

        roots.clear();

        for (int i = 0; i < MAXDEGREE; i++)
        {
            while (!dg[i].empty())
            {
                if (dg[i].size() == 1)
                {
                    roots.push_back(dg[i].back());
                    dg[i].pop_back();
                }
                else
                {
                    int a = dg[i].back(), b;
                    dg[i].pop_back();
                    b = dg[i].back();
                    dg[i].pop_back();

                    dg[i + 1].push_back(Union(a, b));
                }
            }
        }
    }

    // done
    void pop()
    {
        int node = minNode;

        for (auto i : t[node]->children)
        {
            t[i]->parent = -1;
            roots.push_back(i);
        }

        delete t[node];
        t[node] = NULL;

        clean();
    }

    // done
    void cut(int node)
    {
        if (t[node]->parent == -1) return;

        int p = t[node]->parent;

        t[p]->children.erase(t[node]->pos);
        roots.push_back(node);
        t[node]->parent = -1;
        t[node]->isMarked = false;

        if (!t[p]->isMarked) t[p]->isMarked = true;
        else cut(p);
    }

    // done
    void decreaseKey(int node)
    {
        int p = t[node]->parent;

        if (p == -1) return;
        if (t[p]->info.first <= t[node]->info.first) return;

        cut(node);
    }

    // done
    void push(pair<ull, int> val)
    {
        if (t[val.second] == NULL)
        {
            t[val.second] = new Node(val);
            roots.push_back(val.second);
        }
        else
        {
            if (t[val.second]->info.first <= val.first)
                return;
            t[val.second]->info.first = val.first;
            decreaseKey(val.second);
        }

        if (val.first < t[minNode]->info.first)
            minNode = val.second;
    }
};

fastpq pq;
ull dp[N][N], dp2[N];
vector<ii> color[N];
vector<pair<ull, int>> items;

int n, K, M;

void read()
{
    cin >> n >> K >> M;

    for (int i = 0; i < n; i++)
    {
        int k, m, c;
        cin >> k >> m >> c;
        color[k].push_back({m, c});
    }
}

void getMoves()
{
    for (int i = 0; i <= K; i++)
        for (int j = 0; j < M; j++)
            dp[j][i] = INFL;
    dp[0][0] = 0;

    for (int i = 0; i < K; i++)
    {
        for (int j = 0; j < M; j++)
        {
            if (dp[j][i] == INFL) continue;
            
            for (auto&[u, w] : color[i + 1])
                dp[(j + u) % M][i + 1] = 
                    min(dp[(j + u) % M][i + 1], dp[j][i] + (ull)w);
        }
    }

    for (int i = 1; i < M; i++)
        if (dp[i][K] != INFL)
            items.push_back({dp[i][K], i});
}

void dijkstra()
{
    for (auto&i : items)
        pq.push(i);

    while (!pq.empty())
    {
        auto acc = pq.top();
        pq.pop();

        if (dp2[acc.second] != INFL) continue;

        dp2[acc.second] = acc.first;

        for (auto&[cost, m] : items)
        {
            int r = (acc.second + m) % M;

            if (dp2[r] != INFL) continue;

            pq.push({acc.first + cost, r});
        }
    }
}

void solve()
{
    for (int i = 1; i < M; i++) dp2[i] = INFL;

    getMoves();
    dijkstra();

    for (int i = 0; i < M; i++)
    {
        if (dp2[i] == INFL) cout << "-1\n";
        else cout << dp2[i] << '\n';
    }
}
 
int main()
{
    ios_base::sync_with_stdio(0);
    cout.tie(0);
    cin.tie(0);
 
    read();
    solve();
}