import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.NoSuchElementException;
class Process implements Comparable<Process> {
	private String name;
	private int completeTime;
	private int arrivalTime;

	public Process(String name, int completeTime, int arrivalTime) {
		this.name = name;
		this.completeTime = completeTime;
		this.arrivalTime = arrivalTime;
	}

	public int getCompleteTime() {
		return completeTime;
	}

	public void setCompleteTime(int completeTime) {
		this.completeTime = completeTime;
	}

	public String getName() {
		return name;
	}

	public int getArrivalTime() {
		return arrivalTime;
	}

	@Override
	public int compareTo(Process p) {
		int cmp = Integer.compare(arrivalTime, p.arrivalTime);
		if (cmp == 0)
			cmp = Integer.compare(p.completeTime, completeTime);
		return cmp;
	}

}
interface Queue<E> {

	// Elementi na redicata se objekti od proizvolen tip.

	// Metodi za pristap:

	public boolean isEmpty();
	// Vrakja true ako i samo ako redicata e prazena.

	public int size();
	// Ja vrakja dolzinata na redicata.

	public E peek();
	// Go vrakja elementot na vrvot t.e. pocetokot od redicata.

	// Metodi za transformacija:

	public void clear();
	// Ja prazni redicata.

	public void enqueue(E x);
	// Go dodava x na kraj od redicata.

	public E dequeue();

	// Go otstranuva i vrakja pochetniot element na redicata.
	public void sort();

}
class ArrayQueue<E> implements Queue<E> {

	// Redicata e pretstavena na sledniot nacin:
	// length go sodrzi brojot na elementi.
	// Ako length > 0, togash elementite na redicata se zachuvani vo
	// elems[front...rear-1]
	// Ako rear > front, togash vo elems[front...maxlength-1] i
	// elems[0...rear-1]
	E[] elems;
	int length, front, rear;

	// Konstruktor ...

	@SuppressWarnings("unchecked")
	public ArrayQueue(int maxlength) {
		this.elems = (E[]) new Object[maxlength];
		clear();
	}

	public boolean isEmpty() {
		// Vrakja true ako i samo ako redicata e prazena.
		return (length == 0);
	}

	public int size() {
		// Ja vrakja dolzinata na redicata.
		return length;
	}

	public E peek() {
		// Go vrakja elementot na vrvot t.e. pocetokot od redicata.
		if (length > 0)
			return elems[front];
		else
			throw new NoSuchElementException();
	}

	public void clear() {
		// Ja prazni redicata.
		length = 0;
		front = rear = 0; // arbitrary
	}

	public void enqueue(E x) {
		// Go dodava x na kraj od redicata.
		elems[rear++] = x;
		if (rear == elems.length)
			rear = 0;
		length++;
	}

	public E dequeue() {
		// Go otstranuva i vrakja pochetniot element na redicata.
		if (length > 0) {
			E frontmost = elems[front];
			elems[front++] = null;
			if (front == elems.length)
				front = 0;
			length--;
			return frontmost;
		} else
			throw new NoSuchElementException();
	}

	public void sort() {
		Arrays.sort(elems);
	}
}

public class RoundRobin {
	public static void main(String args[]) throws IOException {
		Queue<Process> queue;
		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
		int n = Integer.parseInt(bf.readLine());
		queue = new ArrayQueue<Process>(n);
		for (int i = 0; i < n; i++) {
			String[] parts = bf.readLine().split(" ");
			Process p = new Process(parts[0], Integer.parseInt(parts[1]), Integer.parseInt(parts[2]));
			queue.enqueue(p);
		}
		int runTime = Integer.parseInt(bf.readLine());
		bf.close();
		queue.sort();
		while (!queue.isEmpty()) {
			Process p = queue.dequeue();
			p.setCompleteTime(p.getCompleteTime() - runTime);
			System.out.print(p.getName() + " ");
			if (p.getCompleteTime() > 0)
				queue.enqueue(p);
		}
	}
}