#include<string>
#include<iostream>

int start_word = 0;

struct Element {
    std::string word;
    int index;

    Element* next;
    Element* prev;
    Element() {
        word = "";
        index = 0;
        next = NULL;
        prev = NULL;
    }
};

typedef Element* ElementPtr;

class List {
    int size;
    ElementPtr head;
    ElementPtr tail;

public:
    List();
    ~List();

    void push_back(ElementPtr arg1);
    void insert_data();

    void insert_element(ElementPtr&, ElementPtr);
    void delete_element(ElementPtr arg);

    ElementPtr jump_left(ElementPtr arg, int steps);
    ElementPtr jump_right(ElementPtr arg, int steps);


    void set_size(int size);
    bool isEmpty();

    ElementPtr change_position(ElementPtr curr_el, int index);
    ElementPtr change_position_with_delete(ElementPtr curr_el, int index);
    int count_new_index(int index);
    void create_statement();


    void display_list(); // POMOC

};
List::List() {
    head = NULL;
    tail = NULL;
    size = 0;
}

List::~List() {
}

void List::set_size(int size) {
    this->size = size;
}
void List::display_list() {
    ElementPtr currPtr = head;

    for (int i = 0; i < size; ++i) {
        std::cout << "(" << i << ")   " << "[ " << currPtr->word << ", " << currPtr->index << " ] " << std::endl;
        currPtr = currPtr->next;
    }
}

bool List::isEmpty() {
    return head == NULL;
}

void List::push_back(ElementPtr arg) {

    if (isEmpty()) {
        head = arg;
        tail = arg;

        head->prev = tail;
        head->next = tail;
        tail->next = head;
        tail->prev = head;

    }
    else {
        tail->next = arg;
        arg->prev = tail;
        tail = arg;
        head->prev = tail;
        tail->next = head;
    }
}

void List::insert_element(ElementPtr& curr_el, ElementPtr new_el) {

    new_el->prev = curr_el->prev;
    curr_el->prev->next = new_el;
    curr_el->prev = new_el;
    new_el->next = curr_el;

    ++size;

}

void List::delete_element(ElementPtr arg) {
    if (size == 1)
    {
        size--;
        delete head;
        head = tail = NULL;
        return;
    }
    //if (head == tail) {
    //  //delete head;
    //  --size;
    //  head = tail = NULL;
    //  return;
    //}

    --size;

    arg->prev->next = arg->next;
    arg->next->prev = arg->prev;

    if (arg == tail)
        tail = arg->prev;
    if (arg == head)
        head = arg->next;
    delete arg; // dlaczego to bylo zakomentowane ? ~HSO

}

ElementPtr List::jump_left(ElementPtr arg, int steps) {

    for (int i = steps * (-1); i > 0; --i) {
        arg = arg->prev;
    }

    return arg;
}

ElementPtr List::jump_right(ElementPtr arg, int steps) {

    for (int i = 0; i < steps; ++i) {
        arg = arg->next;
    }

    return arg;
}

ElementPtr get_data_element() {
    ElementPtr tmp = new Element;
    std::cin >> tmp->word >> tmp->index;
    return tmp;
}

void List::insert_data() {
    int n;
    ElementPtr el1 = NULL;

    std::cin >> n >> start_word;
    size = n;

    for (int i = 0; i < n; ++i) {
        el1 = new Element;
        std::cin >> el1->word >> el1->index;
        push_back(el1);
    }

    std::cin >> n;
}


int List::count_new_index(int index) {
    if (size > 0)
        index = index % size;
    else
        return 0; // w przypadku gdy ostatni element jest wyswietlany -> size ==0 nie mamy gdzie przejsc - skonczylismy wyswietlac HSO
    // TO DO TEST 9 & 10 (chyba xD)
    // check if index > 0.5*size
    // if so index = size-abs(index)
    // negate index if it was previously > 0
    // do not negate if it was previously < 0 (will be negated by default)
    return index;
}

ElementPtr List::change_position_with_delete(ElementPtr curr_el, int index) {
    if (index == 0) return curr_el;
    int opposite_index = 0;

    if (index > 0) {
        curr_el = jump_right(curr_el, 1); // przesun w prawo o jeden
        delete_element(curr_el->prev); // usun poprzedni
        opposite_index = count_new_index(index - 1); // przesun w prawo o index -1
    }
    if (index < 0) {
        curr_el = jump_left(curr_el, -1); // przesun w lewo o jeden
        delete_element(curr_el->next); // usun nastepny
        opposite_index = count_new_index(index + 1); // przesun w lewo o index + 1
    }


    if (opposite_index < 0)
        return jump_left(curr_el, opposite_index);
    if (opposite_index > 0)
        return jump_right(curr_el, opposite_index);

    return curr_el; // zwroc NOWY!! element

}

ElementPtr List::change_position(ElementPtr curr_el, int index) {
    int opposite_index = count_new_index(index);
    if (opposite_index < 0)
        curr_el = jump_left(curr_el, opposite_index);

    if (opposite_index > 0)
        curr_el = jump_right(curr_el, opposite_index);

    return curr_el;

}

void List::create_statement() {

    ElementPtr curr_el = NULL;
    ElementPtr new_el = NULL;
    curr_el = head;
    new_el = curr_el;

    int new_index = 0;
    curr_el = change_position(curr_el, start_word);

    while (size > 0) {


        if (curr_el->index == 0) {

            new_el = get_data_element();
            insert_element(curr_el, new_el);

            std::cin >> curr_el->index;
            curr_el = change_position(curr_el, curr_el->index);

        }
        if (curr_el->index != 0) {
            std::cout << "o." << curr_el->word << " " << std::endl;
            curr_el = change_position_with_delete(curr_el, curr_el->index);
        }
    }

}


int main() {
    //std::ios_base::sync_with_stdio(false);

    List list1;
    list1.insert_data();

    list1.create_statement();


    return 0;
}