// Slower C++ solution:
#include<iostream>

#include<algorithm>

#include<vector>

#include<string>

#include<set>

#include<queue>

#include<stack>

#include<bitset>

#include<functional>

#include<map>

#include<iomanip>

#include<limits>

#include<unordered_set>

#include<cmath>

#include <numeric>

#include <array>

#include <complex>

#define M_PI 3.141592653589793238

using namespace std;

//long long p = 998244353;

long long p = 1000000007;

#define int long long

#define ll long long

#define vel vector<ll>

#define vvel vector<vel>

#define rep(i,n) for(int i=0;i<n;i++)

#define sor(v) sort(v.begin(),v.end())

#define mmax(a,b) a=max(a,b)

#define mmin(a,b) a=min(a,b)

#define mkp make_pair

#define pin pair<int,int>

#define qin pair<pin,int>

#define V vector

#define Endl endl

#define veb vector<bool>

#define fcout cout << fixed << setprecision(15)

#define rev(s) reverse(s.begin(),s.end())

#define lower(h,val) (lower_bound(h.begin(),h.end(),val)-h.begin())

#define upper(h,val) (upper_bound(h.begin(),h.end(),val)-h.begin())

vel kai;

vel inv_kai;

int rui(int a, int n, int mod) {

	if (n == 0) { return 1 % mod; }

	int x = rui(a, n / 2, mod);

	x *= x; x %= mod;

	if (n % 2 == 1) { x *= a; x %= mod; }

	return x;

}

int root(int x, vel& pa) {

	if (pa[x] == -1) { return x; }

	int ans = root(pa[x], pa); pa[x] = ans;

	return ans;

}

bool mar(int x, int y, vel& pa) {

	x = root(x, pa);

	y = root(y, pa);

	if (x != y) { pa[x] = y; }

	return (x != y);

}

int gcd(int x, int y) {

	if (x < y) { return gcd(y, x); }

	if (y == 0) { return x; }

	return gcd(y, x % y);

}

int lcm(ll x, ll y) {

	x = abs(x); y = abs(y);

	return x * y / gcd(x, y);

}

long long modinv(long long a, long long m) {

	long long b = m, u = 1, v = 0;

	while (b) {

		long long t = a / b;

		a -= t * b; swap(a, b);

		u -= t * v; swap(u, v);

	}

	u %= m;

	if (u < 0) u += m;

	return u;

}

void make_kai(int max_kai) {

	kai = vel(max_kai, 1);

	inv_kai = kai;

	rep(i, max_kai - 1) {

		kai[i + 1] = kai[i] * (i + 1); kai[i + 1] %= p;

		inv_kai[i + 1] = modinv(kai[i + 1], p);

	}

}

int com(int n, int r) {

	if ((n < 0) || (r < 0) || (r > n)) { return 0; }

	int ans = (kai[n] * inv_kai[r]) % p;

	return (ans * inv_kai[n - r]) % p;

}

vel uni(vel x) {

	if (x.size() == 0) { return x; }

	sor(x);

	int n = x.size();

	vel ans(1, x[0]);

	for (int j = 1; j < n; j++) {

		if (x[j - 1] != x[j]) { ans.push_back(x[j]); }

	}

	x = ans;

	return x;

}

void pr(vel& v) {

	int n = v.size();

	if (n != 0) {

		cout << v[0];

		rep(i, n - 1) {

			cout << " " << v[i + 1];

		}

		cout << endl;

	}

}

vel dijk(V<V<pin>>& way, int st, int inf) {

	int n = way.size();

	vel dist(n, inf); dist[st] = 0;

	priority_queue<pin, vector<pin>, greater<pin>> pq;

	pq.push(mkp(0, st));

	veb is_checked(n, false);

	while (!pq.empty()) {

		pin x = pq.top(); pq.pop();

		int pot = x.second;

		if (!is_checked[pot]) {

			is_checked[pot] = true;

			for (auto y : way[pot]) {

				int nex_dist = x.first + y.second;

				int nex_pot = y.first;

				if (dist[nex_pot] > nex_dist) {

					dist[nex_pot] = nex_dist;

					pq.push(mkp(nex_dist, y.first));

				}

			}

		}

	}

	return dist;

}

vel mul(vel& a, vel& b) {

	int n = a.size();

	int m = b.size();

	vel ans(n + m - 1, 0);

	rep(i, n) {

		rep(j, m) {

			ans[i + j] += a[i] * b[j];

			ans[i + j] %= p;

		}

	}

	return ans;

}

vel rui_p(vel& a, int n) {

	if (n == 0) { return { 1 }; }

	vel qans = rui_p(a, n / 2);

	qans = mul(qans, qans);

	if (n % 2 == 1) {

		qans = mul(qans, a);

	}

	return qans;

}

bool is_prime(int n) {

	if (n == 0 || n == 1) { return false; }

	for (int i = 2; i * i <= n; i++) {

		if (n % i == 0) { return false; }

	}

	return true;

}

#define bs bitset<50>

void per(int& ans) {

	ans %= p;

	if (ans < 0) { ans += p; }

}

#define upperbound(v,val) upper_bound(v.begin(),v.end(),val)-v.begin()

#define lowerbound(v,val) lower_bound(v.begin(),v.end(),val)-v.begin()

#define mat V<V<pin>>

vvel disj_min(vel& v) {

	int n = v.size();

	vvel ret(22, vel(n));

	ret[0] = v;

	rep(i, 21) {

		rep(j, n) {

			int nex = j + (1 << i);

			if (nex < n) {

				ret[i + 1][j] = min(ret[i][j], ret[i][nex]);

			}

			else {

				ret[i + 1][j] = ret[i][j];

			}

		}

	}

	return ret;

}

vvel disj_max(vel& v) {

	int n = v.size();

	vvel ret(22, vel(n));

	ret[0] = v;

	rep(i, 21) {

		rep(j, n) {

			int nex = j + (1 << i);

			if (nex < n) {

				ret[i + 1][j] = max(ret[i][j], ret[i][nex]);

			}

			else {

				ret[i + 1][j] = ret[i][j];

			}

		}

	}

	return ret;

}

int find_min(vvel& dv, int l, int r) {

	int i = 21;

	while (l + (1 << i) > r) {

		i--;

	}

	return min(dv[i][l], dv[i][r - (1 << i)]);

}

int find_max(vvel& dv, int l, int r) {

	int i = 21;

	while (l + (1 << i) > r) {

		i--;

	}

	return max(dv[i][l], dv[i][r - (1 << i)]);

}

void pri(vel& v) {

	if (v.size() == 0) { return; }

	cout << v[0];

	rep(i, v.size() - 1) { cout << " " << v[i + 1]; }

	cout << endl;

	return;

}

vvel dbl(vel& v) {

	vvel ans(20, vel(v));

	int n = v.size();

	rep(i, 19) {

		rep(j, n) {

			ans[i + 1][j] = ans[i][ans[i][j]];

		}

	}

	return ans;

}

int lca(int s, int t, int diff, vvel& pa) {

	if (diff < 0) { return lca(t, s, -diff, pa); }

	rep(i, 19) {

		if ((diff & (1 << i)) != 0) {

			s = pa[i][s];

		}

	}

	for (int i = 19; i >= 0; i--) {

		if (pa[i][s] != pa[i][t]) {

			s = pa[i][s];

			t = pa[i][t];

		}

	}

	if (s != t) {

		s = pa[0][s];

	}

	return s;

}

int sz = 1024 * 1024;

vel bit(sz+1, 0);

void add(int a, int w) {

	while (a<=sz) {

		bit[a] += w;

		a += (a & (-a));

	}

}

int sum(int a) {

	int ans = 0;

	while (a != 0) {

		ans += bit[a];

		a -= (a & (-a));

	}

	return ans;

}

#define vveb V<veb>

#define omajinai cin.tie(0);ios::sync_with_stdio(false);

#define endl "\n"

int modpow(int a, int n, int p) {

	if (n == 0) { return 1; }

	int m = n / 2;

	int x = modpow(a, n / 2, p);

	x *= x; x %= p;

	if (n % 2 == 1) { x *= a; x %= p; }

	return x;

}

pin solve(V<pin>& ab, int ex) {

	if (ex == 0) { return mkp(1, 0); }

	V<pin> ab0, ab1;

	for (auto x : ab) {

		int a1 = x.first;

		int b1 = x.second;

		if (b1 % 2 == 0) {

			ab0.push_back(mkp(a1 / 2,b1 / 2));

			if (a1 % 2 == 1) { ab1.push_back(mkp(a1 / 2, b1 / 2)); }

		}

		else {

			ab1.push_back(mkp(a1 / 2, b1 / 2));

			if (a1 % 2 == 1) { ab0.push_back(mkp(a1 / 2, (b1 + 1) / 2)); }

		}

	}

	vel c0(2), c1(2);

	for (auto x : ab0) {

		int qa = x.first % 3; qa = 3 - qa;

		int qb = x.second % 3;

		int qc = (qa + qb) % 3;

		if (qc == 0) { c0[0] ^= 1; }

		if (qc == 1) { c0[1] ^= 1; }

		if (qc == 2) { c0[0] ^= 1; c0[1] ^= 1; }

	}

	for (auto x : ab1) {

		int qa = x.first % 3; qa = 3 - qa;

		int qb = x.second % 3;

		int qc = (qa + qb) % 3;

		if (qc == 0) { c1[0] ^= 1; }

		if (qc == 1) { c1[1] ^= 1; }

		if (qc == 2) { c1[0] ^= 1; c1[1] ^= 1; }

	}

	vel ze(2, 0);

	if (c0 == ze) {

		pin ans=solve(ab1, ex-1);

		ans.first *= 2; ans.second *= 2;

		ans.second++;

		return ans;

	}

	if (c1 == ze) {

		pin ans = solve(ab0, ex - 1);

		ans.first *= 2; ans.second *= 2;

		return ans;

	}

	rep(i,ab.size()) {ab[i].first++; }

	pin ans = solve(ab, ex);

	ans.first--;

	return ans;

}

signed main() {

	int inf = 1;

	rep(i, 57) { inf *= 2; }

	int n; cin >> n;

	V<pin> ab(n);

	rep(i, n) {

		int a, b; cin >> a >> b;

		a += inf; b += inf;

		ab[i] = mkp(a, b);

	}

	pin ret=solve(ab, 70);

	ret.first -= inf;

	ret.second -= inf;

	cout << ret.first  <<" "<<ret.second<< endl;

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 9.3864255516547x):
#include<iostream>

#include<vector>

using namespace std;

#define int long long

#define V vector

#define vel V<int>

#define rep(i,n) for(int i=0;i<n;i++)

#define mkp make_pair

#define pin pair<int,int>

pin solve(V<pin>& ab, int ex) {

	if (!ex) { return mkp(1,0); }

	V<V<pin>> qab(2);

  int sz=ab.size();

  qab[0].reserve(sz);

  qab[1].reserve(sz);

	for (pin x : ab) {

		qab[x.second & 1].push_back(mkp(x.first / 2,x.second / 2));

		if (x.first & 1) { qab[(x.second + 1) & 1].push_back(mkp(x.first / 2,(x.second + 1) / 2)); }

	}

  vel c(2);

	rep(i, 2) {

		for (pin x : qab[i]) {

			int qc = (2 * x.first + x.second) % 3;

          c[i]^=(qc+1);

		}

	}

	rep(i, 2) {

		if (!c[1 - i]) {

			pin ans = solve(qab[i], ex - 1);

			ans.first *= 2; ans.second *= 2; ans.second += i;

			return ans;

		}

	}

	for(pin &v:ab) { v.first++; }

	pin ans = solve(ab, ex); ans.first--;

	return ans;

}

signed main() {

	long long inf = 2e17;

	int n; scanf("%lld", &n);

	V<pin> ab(n);

	rep(i, n) {

		long long a, b; scanf("%lld", &a); scanf("%lld", &b);

		ab[i] = { a + inf,b + inf };

	}

	pin ret = solve(ab, 70);

	cout << ret.first - inf << " " << ret.second - inf << "\n";

}