#include <iostream>
#include <iostream>
#include <tuple>
#include <algorithm>
#include <string.h>
#include <vector>
#include <set>
using namespace std;

int N, M, K, F;
struct Team {
    int timeP;
    int ty[22];
    int ctime[22];
    int teamNum;
    int correct;
    int isCorrect;
    int lastCorrect;
    int lastCheck;
    void acProb(int T, int p) {
        timeP += T + ty[p] * 20;
        isCorrect ^= 1 << p;
        correct++;
        ctime[p] = T;
        lastCorrect = max(lastCorrect, T);
    }
    void acProb(int T, int p, int tryNum) {
        timeP += T + tryNum * 20;
        isCorrect ^= 1 << p;
        correct++;
        ctime[p] = T;
        lastCorrect = max(lastCorrect, T);
    }
    //맞은 문제인가?
    bool checkProb(int idx) {
        return (isCorrect & (1 << idx)) != 0;
    }
    void init(int idx) {
        teamNum = idx;
        timeP = 0;
        memset(ty, 0, sizeof(ty));
        memset(ctime, 0, sizeof(ctime));
        correct = 0;
        lastCorrect = 0;
        lastCheck = 0;
        isCorrect = 0;
    }
    void copy(Team* b) {
        timeP = b->timeP;
        memcpy(ctime, b->ctime, sizeof(ctime));
        memcpy(ty, b->ty, sizeof(ty));
        teamNum = b->teamNum;
        correct = b->correct;
        isCorrect = b->isCorrect;
        lastCorrect = b->lastCorrect;
        lastCheck = b->lastCheck;
    }
};

bool same(Team *a, Team *b) {
    if ((a->correct == b->correct) &&
        (a->timeP == b->timeP) &&
        (a->lastCorrect == b->lastCorrect))
        return true;
    else
        return false;
}

bool cmp(Team *a, Team *b) {
    if (a->correct == b->correct) {
        if (a->timeP == b->timeP) {
            if (a->lastCorrect == b->lastCorrect)
                return a->teamNum < b->teamNum;
            return a->lastCorrect < b->lastCorrect;
        }
        return a->timeP < b->timeP;
    }
    return a->correct > b->correct;
}

Team* tarr[510];
Team* tarr2[510];
int main() {

    cin >> N >> M >> K >> F;
    int T, t, p, r;
    for (int i = 0; i <= N; i++) {
        tarr[i] = new Team();
        tarr2[i] = new Team();
        tarr[i]->init(i);
        tarr2[i]->init(i);
    }
    int i = 0;
    //freeze 이전처리
    for (; i < K; i++) {
        cin >> T >> t >> p >> r;
        if (T >= F)
            break;
        if (!tarr[t]->checkProb(p)) {
            if (r)
                tarr[t]->acProb(T, p);
            else
                tarr[t]->ty[p]++;
        }
    }
    //복사
    for (int xx = 1; xx <= N; xx++) {
        tarr2[xx]->copy(tarr[xx]);
    }
    //freeze 이후처리
    for (; i < K; i++) {
        if (!tarr2[t]->checkProb(p)) {
            if (r)
                tarr2[t]->acProb(T, p);
            else
                tarr2[t]->ty[p]++;
        }
        if ((i + 1)<K)
            cin >> T >> t >> p >> r;
    }

    int lastIdx = N;
    sort(tarr + 1, tarr + N + 1, cmp);
    vector<tuple<int, int, int>> ans;
    while (lastIdx>0) {
        Team* beforeTeam = tarr[lastIdx];
        Team* afterTeam = tarr2[tarr[lastIdx]->teamNum];
        //모두 확인했는지 체크
        if (same(beforeTeam, afterTeam)) {
            lastIdx--;
        }
        else {
            int myIdx = beforeTeam->teamNum;
            int brank = 1;
            //이전순위체크
            for (int i = lastIdx; i >= 2; i--) {
                if (!same(tarr[i - 1], tarr[i])) {
                    brank = i;
                    break;
                }
            }
            int now = beforeTeam->lastCheck + 1;
            //나중에 맞춘문제 찾기
            while (!(!beforeTeam->checkProb(now) && afterTeam->checkProb(now)))
                now++;
            //cout << now << endl;
            beforeTeam->acProb(afterTeam->ctime[now], now, afterTeam->ty[now]);

            //재정렬
            int idx2 = lastIdx;
            for (; idx2 >= 2; idx2--) {
                if (!cmp(tarr[idx2 - 1], tarr[idx2]))
                    swap(tarr[idx2 - 1], tarr[idx2]);
                else
                    break;
            }
            //이후순위 체크
            int rank = 1;
            for (int i = idx2; i >= 2; i--) {
                if (!same(tarr[i - 1], tarr[i])) {
                    rank = i;
                    break;
                }
            }
            ans.push_back(make_tuple(myIdx, brank, rank));
        }
    }
    int a, b, c;
    cout << ans.size() << endl;
    for (int i = 0; i < ans.size(); i++) {
        tie(a, b, c) = ans[i];
        cout << a << " " << b << " " << c << endl;
    }
    return 0;
}