Problem: 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

Solution (in PYTHON3):

Solution:
import sys

def input():
    return sys.stdin.readline().rstrip()

class Node:
    def __init__(self, value, prev_node, next_node):
        self.value = value
        self.prev_node = prev_node
        self.next_node = next_node

class LinkedList:
    def __init__(self):
        self.current_node = Node(None, None, None)
        self.front_node = self.current_node
        self.end_node = self.current_node

    def insert(self, value):
        current_node = self.current_node
        prev_node = current_node.prev_node
        if prev_node == None:
            newNode = Node(value, None, current_node)
            current_node.prev_node = newNode
            self.current_node = newNode
            self.front_node = newNode
        else:
            newNode = Node(value, prev_node, current_node)
            prev_node.next_node = newNode
            current_node.prev_node = newNode
            self.current_node = newNode

    def remove(self):
        prev_node = self.current_node.prev_node
        next_node = self.current_node.next_node
        if prev_node == None:
            next_node.prev_node = None
            self.front_node = next_node
            self.current_node = next_node
        else:
            next_node.prev_node = prev_node
            prev_node.next_node = next_node
            self.current_node = next_node

    def move(self, diff):
        if diff > 0:
            for _ in range(diff):
                self.current_node = self.current_node.next_node
        elif diff < 0:
            for _ in range(-diff):
                self.current_node = self.current_node.prev_node

    def print(self):
        node = self.front_node
        while node != self.end_node:
            print(node.value)
            node = node.next_node

input()
a = LinkedList()
while True:
    line = input()
    if not line:
        break
    if line[0] == '0':
        a.insert(int(line[2:]))
    elif line[0] == '1':
        a.move(int(line[2:]))
    else:
        a.remove()

a.print()