Problem:
List

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.

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.

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

Sample Input 1

5
0 1
0 2
0 3
1 1
2

Sample Output 1

3
1

Solution in Ruby (judge verdict: Accepted)

class Node
    attr_accessor :value
    attr_accessor :prev
    attr_accessor :next
    def initialize(value="END", prev_node=nil, next_node=nil)
        @value = value
        @prev = prev_node
        @next = next_node
    end
end

class MyList
    def initialize(head = Node.new("END"), cursor = nil)
        @head = head
        @cursor = @head
    end

    def insert(x)
        new_node = Node.new(x)
        unless @cursor.prev.nil? 
            @cursor.prev.next = new_node
            new_node.prev = @cursor.prev
            @cursor.prev = new_node
            new_node.next = @cursor
        else
            new_node.next = @head
            @head.prev = new_node
            @head = new_node
        end
        @cursor = new_node
    end

    def move(n)
        if(n < 0)
            n.upto(-1) { @cursor = @cursor.prev unless @cursor.prev.nil?}
        else
            n.times { @cursor = @cursor.next unless @cursor.next.nil?}
        end
    end

    def erase()
        unless @cursor.value == "END"
            @cursor.next.prev = @cursor.prev
            @cursor.prev.next = @cursor.next unless @cursor.prev.nil?
            @cursor = @cursor.next
            @head = @cursor if @cursor.prev.nil?
        end
    end

    def print
        node = @head
        while(node.value != "END")
            puts node.value
            node = node.next
        end
    end

    def print_cursor
        puts "Current Cursor val: #{@cursor.value}"
        puts "Prev val: #{@cursor.prev.value}" unless @cursor.prev.nil?
        puts "Next val: #{@cursor.next.value}" unless @cursor.next.nil?

    end
end

L = MyList.new()
gets.chomp.to_i.times{
    choice, x = gets.chomp.split(" ")
    case choice
    when "0"
        L.insert(x)
    when "1"
        L.move(x.to_i)
    when "2"
        L.erase()
    end
    # puts "*****"
    # print "Current List: "
    # L.print
    # L.print_cursor
    # puts "*****"

}
L.print