#include <bits/stdc++.h>
#define loop(i,n) for (int i = 0; i < n; ++i)
using namespace std;

using ldbl =   long double;
using cp   = complex<ldbl>;

const ldbl pi = acos(-1), twice_pi = 2*pi, eps = 1e-10;

inline istream& operator>>(istream &in, cp &z) {
    ldbl x, y; in >> x >> y, z = cp(x,y); return in; }

inline ldbl degrees_to_rad(ldbl angle) { return angle*pi/180; }
inline ldbl rad_to_degress(ldbl angle) { return angle*180/pi; }
    
inline ldbl   dot_product(const cp &a, const cp &b) { return real(conj(a)*b); }
inline ldbl cross_product(const cp &a, const cp &b) { return imag(conj(a)*b); }

namespace std {
	bool operator<(const cp &a, const cp &b) {
    	ldbl d;
    	if (abs(d = real(a)-real(b)) > eps)
    		return d < 0;
    	if (abs(d = imag(a)-imag(b)) > eps)
    		return d < 0;
    	return false; } }
    
inline cp polar_to_cartesian(const ldbl rho, const ldbl theta) {
    return polar(rho,theta); }
inline void cartesian_to_polar(const cp &a, ldbl &rho, ldbl &theta) {
    rho = abs(a), theta = arg(a); }

inline cp rotate(const cp &a, const ldbl theta) { 
    return a*polar_to_cartesian(1,theta); }
inline cp rotate(const cp &a, const cp &origin, const ldbl theta) { 
    return origin+(a-origin)*polar_to_cartesian(1,theta); }

inline ldbl squared_distance(const cp &a, const cp &b) { return norm(a-b); }
inline ldbl Euclidean_distance(const cp &a, const cp &b) { return abs(a-b); }
inline ldbl angle(const cp &a, const cp &b) { return arg(a-b); }
inline cp unit_vector(const cp &a) { return polar_to_cartesian(1,arg(a)); }
inline cp projection(const cp &p, const cp &v) { 
    const auto u = unit_vector(v); 
    return dot_product(p,u)*u; }

inline ldbl angle_ABC(const cp &a, const cp &b, const cp &c) {
    ldbl g = angle(b,a)-angle(b,c); 
    if (g <= -pi) // return g in semi-closed interval ]-pi,pi]
        g += twice_pi;
    if (g > pi)
        g -= twice_pi;
    return g; }

inline ldbl triangle_area(const cp &a, const cp &b, const cp &c) {
    const ldbl A = abs(b-a), B = abs(c-b), C = abs(a-c), s = (A+B+C)/2;
    return sqrt(s*(s-A)*(s-B)*(s-C)); }
    
struct line: pair<cp,cp> {
	ldbl slope() const { return tan(angle(first,second)); }
	cp to_vector() const { return second-first; }
	cp projection_onto(const cp &p) const {
    	const auto c = p-first, d = to_vector(); 
    	return projection(c,d); }     
	cp projection_across(const cp &p) const {
    	const auto c = p-first, d = to_vector(); 
    	return c-projection(c,d); }
    cp reflect_across(const cp &p) const {
    	static const auto two = cp(2,0); 
    	const auto c = p-first, d = to_vector(); 
    	return two*(first+projection(c,d))-p; }
    bool parallel(const line &b) const {
    	const auto c = to_vector(), u = b.first-first, v = b.second-second;
    	return abs(cross_product(u,c)-cross_product(v,c)) < eps; }
	cp intersection(const line &b) const {
    	const auto c = to_vector(), u = b.first-first, v = b.second-second;
    	const auto c1 = cross_product(u,c), c2 = cross_product(v,c);
    	return (c1*b.second-c2*b.first)/(c2-c1); } };

int main() {  
 
    int n; ldbl x; vector<cp> v;
    
    cin >> n, v.resize(n);
   
    loop(i,n)
        cin >> v[i];
        
    sort(v.begin(),v.end());   
    
    loop(i,n)
        cout << v[i] << ' '; }