import ImmutableList.*

fun main(args:Array<String>):Unit {
    val list = LinkList()
    repeat(readLine()!!.toInt()){
        val arg = readLine()!!.split(' ').map(String::toInt)
        when(arg.first()){
            0 -> list.insert(arg.last())
            1 -> list.move(arg.last())
            else -> list.erase()
        }
    }
    println(list)
}
fun <T, A:T> ImmutableList<T>.append(value:A):ImmutableList<T> = Cons(value, this)
sealed class ImmutableList<out T>:Iterable<T>{
    override fun iterator(): Iterator<T> {
        return ListIterator(this)
    }
    object Nil:ImmutableList<Nothing>()
    data class Cons<out T>(val head:T, val tail:ImmutableList<T>):ImmutableList<T>()
}
class ListIterator<out T>(private var list:ImmutableList<T>):Iterator<T> {
    override fun hasNext(): Boolean = list is Cons

    override fun next(): T {
        val next = list as Cons
        list = next.tail
        return next.head
    }

}
class LinkList{
    private var mPrev:ImmutableList<Int> = Nil
    private var mNext:ImmutableList<Int> = Nil
    private fun moveForward():Unit {
        val next = mNext as Cons
        mPrev = Cons(next.head, mPrev)
        mNext = next.tail
    }
    private fun moveBackward():Unit {
        val prev = mPrev as Cons
        mPrev = prev.tail
        mNext = Cons(prev.head, mNext)
    }
    fun insert(value:Int):Unit {
        mNext = Cons(value, mNext)
    }
    fun move(value:Int):Unit {
        if (value >= 0){
            repeat(value){moveForward()}
        }else{
            repeat(-value){moveBackward()}
        }
    }
    fun erase():Unit {
        mNext = (mNext as Cons<Int>).tail
    }

    override fun toString(): String {
        return listOf(mPrev.reversed(), mNext).flatten().joinToString ("\n")
    }
}
