import java.io.*;
import java.util.*;
import java.math.*;

public class Main implements Runnable {
    private BufferedReader in;
    private PrintWriter out;
    private StringTokenizer st;
    private Random rnd;

    class Lesson implements Comparable<Lesson> {
        long a, b;
        int c, diff;

        Lesson(long a, long b, int c) {
            this.a = a;
            this.b = b;
            this.c = c;
            this.diff = (int) (b - a);
        }

        public int compareTo(Lesson o) {
            return this.c - o.c;
        }
    }

    class Pair {
        int lesson, diff;

        Pair(int a, int b) {
            this.lesson = a;
            this.diff = b;
        }
    }

    final int max = 110;

    public void solve() throws IOException {
        int daysCount = nextInt(), lessonsCount = nextInt();
        long k = nextLong();

        Lesson[] lessons = new Lesson[lessonsCount];
        for(int i = 0; i < lessonsCount; i++) lessons[i] = new Lesson(nextLong(), nextLong(), nextInt());
        //Arrays.sort(lessons);

        boolean[][][] d = new boolean[daysCount + 1][lessonsCount][110];
        Pair[][][] p = new Pair[daysCount + 1][lessonsCount][110];
        long[][][] total = new long[daysCount + 1][lessonsCount][110];

        // base
        for(int lesson = 0; lesson < lessonsCount; lesson++) {
            for(int tasks = 0; tasks <= lessons[lesson].diff; tasks++) {
                d[1][lesson][tasks] = true;
                total[1][lesson][tasks] = lessons[lesson].a + (long) tasks;
            }
        }

        // dyn
        for(int day = 1; day < daysCount; day++) {
            for(int curLes = 0; curLes < lessonsCount; curLes++) {
                for(int newLes = 0; newLes < lessonsCount; newLes++) {
                    if(lessons[curLes].c >= lessons[newLes].c) continue;

                    for(int tasks = 0; tasks < max; tasks++) {
                        if(!d[day][curLes][tasks]) continue;

                        long var1 = (lessons[curLes].a + (long) tasks) + k;
                        long var2 = (lessons[curLes].a + (long) tasks) * k;


                        //out.println((day + 1) + " " + var1 + " " + var2);

                        if(lessons[newLes].a <= var1 && var1 <= lessons[newLes].b) {
                            int diff = (int) (var1 - lessons[newLes].a);

                            long new_total = total[day][curLes][tasks] + var1;

                            if(!d[day + 1][newLes][diff] || new_total > total[day + 1][newLes][diff] ) {
                                d[day + 1][newLes][diff] = true;
                                p[day + 1][newLes][diff] = new Pair(curLes, tasks);
                                total[day + 1][newLes][diff] = new_total;
                            }
                        }

                        if(lessons[newLes].a <= var2 && var2 <= lessons[newLes].b) {
                            int diff = (int) (var2 - lessons[newLes].a);

                            long new_total = total[day][curLes][tasks] + var2;

                            //out.println(diff);

                            if(!d[day + 1][newLes][diff] || new_total > total[day + 1][newLes][diff] ) {
                                d[day + 1][newLes][diff] = true;
                                p[day + 1][newLes][diff] = new Pair(curLes, tasks);
                                total[day + 1][newLes][diff] = new_total;
                            }
                        }
                    }
                }
            }
        }

        int daysPointer = daysCount;
        int lesPointer = -1;
        int tasksPointer = -1;
        boolean finded = false;
        long curRes = -1;



        for(int les = 0; les < lessonsCount; les++) {
            for(int tasks = 0; tasks < max; tasks++) {
                if(d[daysCount][les][tasks]) {
                    finded = true;

                    if(total[daysCount][les][tasks] > curRes) {
                        curRes = total[daysCount][les][tasks];
                        lesPointer = les;
                        tasksPointer = tasks;
                    }
                }
            }
        }

        if(finded) {
            out.println("YES");

            Stack<Pair> path = new Stack<Pair>();
            path.add(new Pair(lesPointer, tasksPointer));

            while(daysPointer > 1) {
                Pair curPair = p[daysPointer][lesPointer][tasksPointer];
                path.add(curPair);

                --daysPointer;
                lesPointer = curPair.lesson;
                tasksPointer = curPair.diff;
            }

            for(int i = 0; i < daysCount; i++) {
                Pair curPair = path.pop();

                int id = curPair.lesson + 1;
                long howMuch = lessons[curPair.lesson].a + (long) curPair.diff;

                out.println(id + " " + howMuch);
            }
        } else {
            out.println("NO");
        }
    }


    public void run() {
        try {
            //in = new BufferedReader(new FileReader("input.txt"));
            //out = new PrintWriter(new FileWriter("output.txt"));

            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);

            st = null;
            rnd = new Random();

            solve();

            out.close();
        } catch(Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    public static void main(String[] args) {
        new Main().run();
    }

    private String nextToken() throws IOException, NullPointerException {
        while(st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }

        return st.nextToken();
    }

    private int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    private long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    private double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
}