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
class Node():
    def __init__(self, prv = None, nxt = None, val = None):
        self.prv = prv
        self.nxt = nxt
        self.val = val

class DoublyLinkedList():
    def __init__(self):
        self.head = Node(prv=None, nxt=None, val="H")
        self.cur_node = self.head
        self.tail = Node(prv=None, nxt=None, val="E")
        
    def insert(self, x):
        if self.cur_node == self.head:
            new_node = Node(prv=None, nxt=None, val=x)

            new_node.prv = self.head
            new_node.nxt = self.tail

            self.head.nxt = new_node
            self.tail.prv = new_node

            self.cur_node = new_node

        elif self.cur_node == self.tail:
            new_node = Node(prv=None, nxt=None, val=x)

            self.tail.prv.nxt = new_node

            new_node.prv = self.tail.prv
            new_node.nxt = self.tail
            
            self.tail.prv = new_node
            self.cur_node = new_node
            
        else:
            new_node = Node(prv=None, nxt=None, val=x)

            if self.cur_node.prv is self.head:
                new_node.prv = self.head
                self.head.nxt = new_node
            else:
                new_node.prv = self.cur_node.prv
                self.cur_node.prv.nxt = new_node
               
            if self.cur_node is not self.tail:
                new_node.nxt = self.cur_node
                self.cur_node.prv = new_node

            self.cur_node = new_node

    def move(self, d):
        if d > 0:
            for _ in range(d):
                if self.cur_node.nxt is not None:
                    self.cur_node = self.cur_node.nxt
        elif d < 0:
            for _ in range(-d):
                self.cur_node = self.cur_node.prv
            
    def erase(self):
        prv = self.cur_node.prv
        nxt = self.cur_node.nxt

        if prv is self.head:
            self.head.nxt = nxt
        else:
            prv.nxt = nxt

        nxt.prv = prv
        self.cur_node = nxt

    def dump(self):
        cur = self.head.nxt

        while True:
            if cur is self.tail :
                break
            
            print(cur.val)
            cur = cur.nxt

def main():
    dll = DoublyLinkedList()
    q = int(input())

    for _ in range(q):
        com, *para = map(int, input().split())

        if   com == 0:
            dll.insert(para[0])

        elif com == 1:
            dll.move(para[0])

        elif com == 2:
            dll.erase()
    dll.dump()
    
main()
