OI XXXIII - spo

// https://szkopul.edu.pl/problemset/problem/Nj5KslMblkAfffMZtJPVBjxl/site/?key=statement

#include <bits/stdc++.h>

// #define GARY_DBG
#define GARY_LIB

constexpr int sizik = 1000 * 1001;

#define int int64_t

#define ar std::array

typedef std::vector<std::vector<int>> _kra;
int n;

struct Point {
    int u, v;
};

int mask_count[16];

std::vector<Point> cand;

inline int mod2(int x) {
    return ((x % 2) + 2) % 2;
}

constexpr int X = 1;
void add_cand(int u, int v) {
    for (int i = -X; i <= X; i++) {
        for (int j = -X; j <= X; j++) {
            if (mod2(u + i) == mod2(v + j)) {
                cand.push_back({u + i, v + j});
            }
        }
    }
}

void add_cand(const Point& p) {
    return add_cand(p.u, p.v);
}

struct Ans {
    int x, y, f;
};
Ans ans[sizik];

int inline abss(int x) {
    return x > 0 ? x : -x;
}

void solve() {
    std::cin >> n;

    int u_min = INT64_MAX, u_max = INT64_MIN;
    int v_min = INT64_MAX, v_max = INT64_MIN;

    std::vector<Point> points;
    points.reserve(n);
    cand.reserve(500);

    for (int i = 0; i < n; i++) {
        int x, y;
        std::cin >> x >> y;

        int u = x - y, v = x + y;
        u_min = std::min(u_min, u);
        v_min = std::min(v_min, v);
        u_max = std::max(u_max, u);
        v_max = std::max(v_max, v);

        points.push_back({u, v});
    }

    for (const auto& p : points) {
        int mask = 0;
        if (p.u == u_min) mask |= 1;
        if (p.u == u_max) mask |= 2;
        if (p.v == v_min) mask |= 4;
        if (p.v == v_max) mask |= 8;
        mask_count[mask]++;
    }

    int u_mid = (u_min + u_max) / 2;
    int v_mid = (v_min + v_max) / 2;
    int du = (u_max - u_min) / 2;
    int dv = (v_max - v_min) / 2;

    constexpr static int D = 1e14;

    add_cand(D, 0);
    add_cand(-D, 0);
    add_cand(0, D);
    add_cand(0, -D);

    add_cand(u_min + D, v_min + D);
    add_cand(u_max - D, v_min + D);
    add_cand(u_max - D, v_max - D);
    add_cand(u_min + D, v_max - D);

    add_cand(u_mid, v_mid);

    add_cand(u_mid, v_min + du);
    add_cand(u_mid, v_min - du);
    add_cand(u_mid, v_max + du);
    add_cand(u_mid, v_max - du);
    add_cand(u_min + dv, v_mid);
    add_cand(u_min - dv, v_mid);
    add_cand(u_max + dv, v_mid);
    add_cand(u_max - dv, v_mid);

    for (const auto& p : cand) {
        int dL = abss(p.u - u_min);
        int dR = abss(p.u - u_max);
        int dD = abss(p.v - v_min);
        int dG = abss(p.v - v_max);

        int maxi = std::max({dL, dR, dD, dG});

        int active = 0;
        if (dL == maxi) active |= 1;
        if (dR == maxi) active |= 2;
        if (dD == maxi) active |= 4;
        if (dG == maxi) active |= 8;

        int cnt = 0;

        for (int i = 1; i < 16; i++) {
            if (i & active) {
                cnt += mask_count[i];
            }
        }

        if (cnt >= 1 && cnt <= n) {
            ans[cnt] = {(p.u + p.v) / 2, (p.v - p.u) / 2, true};
        }
    }

    for (int i = 1; i <= n; i++) {
        if (ans[i].f) {
            std::cout << ans[i].x << " " << ans[i].y << '\n';
        } else {
            std::cout << "NIE\n";
        }
    }
}

int32_t main() {
#ifndef GARY_DBG
    std::ios_base::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);
#endif

    int t = 1;
    // std::cin >> t;

    for (; t > 0; t--) {
        solve();
    }

    return 0;
}