#include <iostream>
#include <vector>
using namespace std;

class Entry {
  public:
	long long phone_number;
	string name;
    Entry(string, long long);
    Entry(){};
};

Entry::Entry (string fname, long long p_number){
	name = fname;
	phone_number = p_number;
};

template<class T>
class Tree {
  public: 
    T data;
    Tree* left;
    Tree* right;
    Tree* parent;
    Tree(T);
    void insert(T, Tree*);
    Tree<T>* search(string);
    Tree<T>* min();
    Tree<T>* max();
    Tree<T>* traverse();
    Tree<T>* successor();
    Tree<T>* predecessor();
};

template <class T>
Tree<T>::Tree (T node_data){
	left = NULL;
	right = NULL;
	parent = NULL;
	data = node_data;
};

template <class T>
Tree<T>* Tree<T>::traverse(){
	if (left != NULL){
		left->traverse();
	}
	cout << "Data: " << data.name << " : " << data.phone_number << endl;
	if (right != NULL){
		right->traverse();
	}
}


template <class T>
Tree<T>* Tree<T>::min(){
	if (left == NULL){
		return this;
	}
	return left->min();
}

template <class T>
Tree<T>* Tree<T>::successor(){
    if (right != NULL){
    	return right->min();
    }
    Tree<T>* up_one = parent;
    Tree<T>* proxy = this;
    while ((up_one != NULL) and (proxy == up_one->right)){
    	proxy = up_one;
    	up_one = up_one->parent;
    }
    return up_one;
}

template <class T>
Tree<T>* Tree<T>::predecessor(){
    if (left != NULL){
    	return left->max();
    }
    Tree<T>* up_one = parent;
    Tree<T>* proxy = this;
    while ((up_one != NULL) and (proxy == up_one->left)){
    	proxy = up_one;
    	up_one = up_one->parent;
    }
    return up_one;
}

template <class T>
Tree<T>* Tree<T>::max(){
	if (right == NULL){
		return this;
	}
	return right->max();
}

template <class T>
Tree<T>* Tree<T>::search(string fname){
	if (data.name == fname){
		return this;
	}
	if (data.name < fname){
		if (right == NULL){
			return right;
		}
		return right->search(fname);
	}
	if (data.name > fname){
		if (left == NULL){
			return left;
		}
		return left->search(fname);
	}
}

template <class T>
void Tree<T>::insert(T node_data, Tree * t_parent){
	if (data.name < node_data.name){
		if (right == NULL){
			right = new Tree<T> (node_data);
			right->parent = this;
			return;
		} 
		right->insert(node_data, this);
		return;
	}; 
	
	if (left == NULL){
		left = new Tree<T> (node_data);
		left->parent = this;
		return;
	};
	left->insert(node_data, this);
	return;
};

void load_n_phone_numbers(int n, Tree<Entry>*& myTree){
  int i;
  long long p_number;
  string fname;
  for (i = 0; i < n; i++){
  	cin >> fname >> p_number;
    if (myTree == NULL) {
    	myTree = new Tree<Entry>(Entry(fname, p_number));
    } else {
    	myTree->insert(Entry(fname, p_number), NULL);
    }
  }
  return;
}; 

int main() {
	int n;
	Tree<Entry>* myTree = NULL;
	Tree<Entry>* result;
	Tree<Entry>* next_result;
	scanf("%d", &n);
    load_n_phone_numbers(n, myTree);
    result = myTree->search("andy");
    cout << "Andy's number is: ";
    if (result == NULL){
    	cout << "No such string" << endl;
    } else {
    	cout << result->data.phone_number << endl;
    }
    cout << "Person after Andy is: " << endl;
    next_result = result->successor();
    if (next_result == NULL){
    	cout << "No one " << endl;
    }
    else {
    	cout << " named : " << next_result->data.name << endl;
    }
    myTree->traverse();
	return 0;
};