#include <iostream>
#include <stdexcept>
#include <string>
#include <sstream>
#include <limits>
#include <map>
struct Customer
{
    double X;
	double Y;
	explicit Customer(double X = 0., double Y = 0.)
		: X(X), Y(Y)
	{
	}
};
template<typename CharT>
std::basic_istream<CharT>& operator>> (std::basic_istream<CharT>& Stream, Customer& Object)
{
	if(!(Stream >> Object.X) || !(Stream >> Object.Y))
	{
		throw std::invalid_argument(std::string("Couldn't parse input"));
	}
	return Stream;
}
template<typename CharT, typename Traits>
std::basic_ostream<CharT, Traits>& operator<< (std::basic_ostream<CharT, Traits>& Stream, Customer const& Object)
{
	::std::basic_ostringstream<CharT, Traits> StrStream;
	StrStream.flags(Stream.flags());
	StrStream.imbue(Stream.getloc());
	StrStream.precision(Stream.precision());
	
	StrStream << Object.X << '\t' << Object.Y;
	
	return Stream << StrStream.str();
}
int main()
{
    std::istream& Source = std::cin;
	Source.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
	typedef std::map<unsigned, Customer> ListType;
	ListType List;
	{
		unsigned Nr;
		Customer InputCustomer;
		try
		{
			while((Source >> Nr) && (Source >> InputCustomer))
			{
				List[Nr] = InputCustomer;
			}
		}
		catch(std::invalid_argument const& Exception)
		{
			std::cerr << Exception.what();
			return -1;
		}
	}
	std::cout << "Nr.\tX\tY\n";
	for(ListType::const_iterator i = List.begin(); i != List.end(); ++i)
	{
		std::cout << i->first << '\t' << i->second << '\n';
	}
}