#include<iostream>
#include<string>
#include<cassert>

using namespace std;

class Punkt
{
private:
    string nazwa;
    double X;
    double Y;
public:
    Punkt(string n, double x, double y)
    {
        nazwa = n;
        X = x;
        Y = y;
    }
    string ret_nazwa();
    double ret_x();
    double ret_y();
    double suma();
};

string Punkt::ret_nazwa()
{
    return nazwa;
}

double Punkt::ret_x()
{
    return X;
}

double Punkt::ret_y()
{
    return Y;
}

double Punkt::suma()
{
    return X + Y;
}

bool operator < (Punkt &a, Punkt &b)
{
    if (a.suma() == b.suma())
    {
        if (a.ret_x() == b.ret_x())
            return a.ret_nazwa() < b.ret_nazwa();
        else
            return a.ret_x() < b.ret_x();
    }
    else
        return a.suma() < b.suma();
}

ostream & operator << (ostream & strumien, Punkt jakis)
{
    return strumien << jakis.ret_nazwa() << " " << jakis.ret_x() << " " << jakis.ret_y() << " ";
}

template <class T> class link;
template <class T> class Iterator;

template <class T>
class list {
protected:
    link <T> *First;
public:
    list() : First(nullptr) {}
    list(const list &source);
    virtual ~list() {};
    virtual void add(T value);
    virtual void delete_all();

    friend class Iterator <T>;
};

template <class T>
class link {
private:
    T Value;
    link <T> *Next;
    link(T val, link *ptr) : Value(val), Next(ptr) { }
public:
    link <T> *insert(T value);

    friend class list <T>;
    friend class Iterator <T>;
};

template <class T> class Iterator {
public:
    Iterator(list <T> &aList);
    virtual bool init();
    virtual T operator()();
    virtual bool operator !();
    virtual bool operator++();
    virtual bool operator++(int);
    virtual void operator=(T value);
    void remove_current();
    void add_before(T new_value);
protected:
    list <T> &my_list;
    link <T> *previous;
    link <T> *current;
};


template <class T> link <T> * link <T> ::insert(T value)
{
    Next = new link <T>(value, Next);
    return Next;
}


template <class T> void list <T> ::add(T value)
{
    Iterator <T> itr(*this);
    for (itr.init(); !itr; ++itr)
    {
        T x = itr();
        if (value < x)
        {
            itr.add_before(value);
            return;
        }
    }
    itr.add_before(value);
}

template <class T> void list <T> ::delete_all() {
    link <T> *next;
    for (link <T> *p = First; p; p = next) {
        next = p->Next;
        delete p;
    }
    First = nullptr;
}

template <class T> Iterator <T> ::
Iterator(list <T> &aList) : my_list(aList) {
    init();
}
template <class T> bool Iterator <T> ::init() {
    previous = nullptr;
    current = my_list.First;
    return current != nullptr;
}
template <class T> T Iterator <T> :: operator()() {
    assert(current != nullptr);
    return current->Value;
}
template <class T> void Iterator <T> :: operator=(T val) {
    assert(current != nullptr);
    current->Value = val;
}

template <class T> void Iterator <T> ::remove_current()
{
    assert(current != nullptr);
    if (previous == nullptr)
        my_list.First = current->Next;
    else
        previous->Next = current->Next;
    delete current;
    current = nullptr;
}

template <class T> bool Iterator <T> :: operator++() {
    if (current == nullptr)
    {
        if (previous == nullptr)
            current = my_list.First;
        else
            current = previous->Next;
    }
    else {
        previous = current;
        current = current->Next;
    }
    return current != nullptr;
}

template <class T> bool Iterator <T> :: operator++(int) {
    return operator++();
}

template <class T> bool Iterator <T> :: operator !() {
    if (current == nullptr and previous != nullptr)
        current = previous->Next;
    return current != nullptr;
}


template <class T> void Iterator <T> ::add_before(T val)
{
    if (previous)previous = previous->insert(val);
    else {
        my_list.First = new link<T>(val, my_list.First);
        previous = my_list.First;
        current = previous->Next;
    }
}


int main()
{
    list<Punkt> myList;
    Iterator<Punkt> myIterator(myList);
    double a,b;
    string n;
    for (int i = 0; i < 6; i++)
    {
        cin >> n;
        cin >> a;
        cin >> b;
        myList.add(Punkt(n, a, b));
    }
    double c;
    cin >> c;
    for (myIterator.init(); !myIterator; ++myIterator)
    {
        if (c == myIterator().suma())
            myIterator.remove_current();
    }
    for (myIterator.init(); !myIterator; ++myIterator)
    {
        cout << myIterator();
    }

    return 1;
}