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 JAVA):

Solution:
import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;

class Scanner {
    private final InputStream in = System.in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int buflen = 0;

    private boolean hasNextByte() {
        if (ptr < buflen) {
            return true;
        } else {
            ptr = 0;
            try {
                buflen = in.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (buflen <= 0) {
                return false;
            }
        }
        return true;
    }

    private int readByte() {
        return hasNextByte() ? buffer[ptr++] : -1;
    }

    private boolean isPrintableChar(int c) {
        return 33 <= c && c <= 126;
    }

    private void skipUnprintable() {
        while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
    }

    public boolean hasNext() {
        skipUnprintable();
        return hasNextByte();
    }

    public String next() {
        if (!hasNext()) throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while (isPrintableChar(b)) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    public int nextInt() {
        return (int) nextLong();
    }

    public long nextLong() {
        if (!hasNext()) throw new NoSuchElementException();
        long n = 0;
        boolean minus = false;
        int b = readByte();
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        if (b < '0' || '9' < b) {
            throw new NumberFormatException();
        }
        while (true) {
            if ('0' <= b && b <= '9') {
                n *= 10;
                n += b - '0';
            } else if (b == -1 || !isPrintableChar(b)) {
                return minus ? -n : n;
            } else {
                throw new NumberFormatException();
            }
            b = readByte();
        }
    }
}

class CursorList<E> {
	public CursorList<E> prev;
	public CursorList<E> next;
	public boolean isEnd;
	E value;

	public CursorList() {
		this.isEnd = true;
		this.prev = null;
		this.next = null;
	}
	private CursorList(CursorList<E> cursor, E x)
	{
		this.isEnd = false;
		this.value = x;
		this.next = cursor;
		if (cursor.prev != null) {
			cursor.prev.next = this;
			this.prev = cursor.prev;
		} else {
			this.prev = null;
		}
		cursor.prev = this;
	}

	public CursorList<E> insert(E x) {
		this.prev = new CursorList<E>(this, x);
		return this.prev;
	}

	public CursorList<E> move(int d) {
		if (d == 0) {
			return this;
		} else if (d > 0) {
			CursorList<E> tmp = this;
			for (int i = 0; i < d; ++i) {
				tmp = tmp.next;
			}
			return tmp;
//			return next.move(d - 1);
		} else {
			CursorList<E> tmp = this;
			for (int i = 0; i < (-d); ++i) {
				tmp = tmp.prev;
			}
			return tmp;
//			return prev.move(d + 1);
		}
	}

	public CursorList<E> erase() {
		if (this.isEnd) return this;

		if (this.prev != null) {
			this.prev.next = this.next;
		}
		this.next.prev = this.prev;
		return this.next;
	}

	public E get() {
		return value;
	}

	public CursorList<E> top() {
		CursorList<E> tmp = this;
		while(tmp.prev != null) {
			tmp = tmp.prev;
		}
		return tmp;
//		if (this.prev != null) {
//			return this.prev.top();
//		} else {
//			return this;
//		}
	}

}


public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner();
		int q = sc.nextInt();
		CursorList<Integer> list = new CursorList<Integer>();
	    for (int i = 0; i < q; ++i)
	    {
	    	int query = sc.nextInt();
	    	switch (query) {
	    	case 0:
	    		int x = sc.nextInt();
	    		list = list.insert(x);
	    		break;
	    	case 1:
	    		int d = sc.nextInt();
	    		list = list.move(d);
	    		break;
	    	case 2:
	    		list = list.erase();
	    		break;
	    	}

	    }
	    list = list.top();
	    while (!list.isEnd) {
	    	System.out.println(list.value);
	    	list = list.move(1);
	    }
	}


}