For a dynamic list $L$ of integers, perform a sequence of the following operations. $L$ has a special element called END at the end of the list and an element of $L$ is indicated by a cursor.

* insert($x$): Insert $x$ before the element indicated by the cursor. After this operation, the cursor points the inserted element.
* move($d$): Move the cursor to the end by $d$, if $d$ is positive. Move the cursor to the front by $d$, if $d$ is negative.
* erase(): Delete the element indicated by the cursor. After this operation, the cursor points the element next to the deleted element. In case there is no such element, the cursor should point END.



In the initial state, $L$ is empty and the cursor points END.

Constraints

* $1 \leq q \leq 500,000$
* The cursor indicates an element of $L$ or END during the operations
* Erase operation will not given when the cursor points END
* $-1,000,000,000 \leq x \leq 1,000,000,000$
* Moving distance of the cursor ($\sum{|d|}$) does not exceed 1,000,000
* $L$ is not empty after performing all operations

Input

The input is given in the following format.


$q$
$query_1$
$query_2$
:
$query_q$


Each query $query_i$ is given by


0 $x$


or


1 $d$


or


2


where the first digits 0, 1 and 2 represent insert, move and erase operations respectively.

Output

Print all elements of the list in order after performing given operations. Print an element in a line.

Example

Input

5
0 1
0 2
0 3
1 1
2


Output

3
1

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {

	public static int END_VALUE = Integer.MIN_VALUE;
	public static int DEL_VALUE = Integer.MIN_VALUE+1;
	public static int EMPTY_VALUE = Integer.MIN_VALUE+2;
	public static int MIN_VALUE = -1000000000;
	public static int MAX_VALUE =  1000000000;

	public static int MIN_COMMAND = 1;
	public static int MAX_COMMAND = 500000;

	public static void main(String[] args) throws Exception {
		doCommnand(initCommand());
	}

	private static ArrayElement END = new ArrayEnd();

	private static void doCommnand(String[][] commandList) {
		ArrayElement cursor = END; 

		int sumDistance = 0;
		for (String[] commandInfo : commandList) {
			String command = commandInfo[0];
			// insert x
			if (command.equals("0")) {
				int value = Integer.parseInt(commandInfo[1]);
				cursor = cursor.insert(value);
				// move d
			} else if (command.equals("1")) {
				int value = Integer.parseInt(commandInfo[1]);
				int distance;
				if (value < 0) {
					distance = -value;
				} else {
					distance = value;
				}
				sumDistance += distance;
				if (sumDistance > 1000000) {
					throw new IllegalArgumentException("command is illegal");
				}
				cursor = cursor.move(value);
				// erase
			} else if (command.equals("2")) {
				if (cursor !=  null) {
					cursor = cursor.delete();
				}
			}
			//scanAndDump(cursor, ",");
			//System.out.println("");
		}
		scanAndDump(cursor, "\n");
	}
	private static void scanAndDump(ArrayElement element, String delimitor) {
		if (element.isEnd()) {
			return;
		}

		ArrayElement scanElement = element;
		while(true) {
			if (scanElement.previous == null) {
				break;
			}
			scanElement = scanElement.previous;
		}

		ArrayElement printElement =  scanElement;
	
		StringBuilder builder = new StringBuilder();
		while(true) {
			builder.append(printElement.value);
			builder.append(delimitor);
			if (printElement.next.isEnd()) {
				break;
			}
			printElement = printElement.next;
		}
		System.out.print(builder.toString());
	}

	public static class ArrayElement {

		private ArrayElement previous;

		private ArrayElement next;

		int value;
		
		boolean isEnd() {
			return false;
		}

		public ArrayElement(int value) {
			validateValue(value);
			this.value = value;
		}

		public ArrayElement insert(int value) {
			validateValue(value);
			ArrayElement newElement = new ArrayElement(value);
			newElement.previous = previous;
			newElement.next = this;
			if (previous != null) {
				previous.next = newElement;
			}
			previous = newElement;
			return newElement;
		}

		public ArrayElement delete() {
			if (previous != null) {
				previous.next = next;
			}
			if (next != null) {
				next.previous = previous;
			}
			return next;
		}

		public ArrayElement move(int x) {
			int direction = 0;
			int distance = 0;
			if (x > 0) {
				direction = 1;
				distance = x;
			} else if (x < 0) {
				direction = -1;
				distance = -x;
			}
			ArrayElement element = this;
			for (int i=0; i<distance; i++) {
				if (direction == 1) {
					element = element.next;
				} else if (direction == -1) {
					element = element.previous;
				}
				if (element.isEnd()) {
					return END;
				}
			}
			return element;
		}
		private void validateValue(int value) {
			if (value < MIN_VALUE || value > MAX_VALUE) {
				throw new IllegalArgumentException("command is illegal");
			}
		}
	}
	
	public static class ArrayEnd extends ArrayElement {
		
		public ArrayEnd() {
			super(0);
		}
		
		public boolean isEnd() {
			return true;
		}
	}
	
	private static String[][] initCommand() throws IOException {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String numCommandStr = br.readLine();
		int commandNum = Integer.parseInt(numCommandStr);
		if (commandNum < MIN_COMMAND || commandNum > MAX_COMMAND) {
			throw new IllegalArgumentException(MIN_COMMAND + " <= commandNum <= " + MAX_COMMAND);
		}
		String[][] commandList = new String[commandNum][];
		for (int i=0; i< commandNum; i++) {
			String line = br.readLine();
			if (line == null || line.isEmpty()) {
				throw new IllegalArgumentException("command is empty");
			}
			commandList[i] = line.split(" ", -1);
		}
		return commandList;
	}
}

