```#include <cassert>
#include <cmath>
#include <iostream>
#include <iomanip>
#include <cmath>
#include <sstream>
#include <iterator>
#include <string>
#include <vector>
#include <set>
#include <list>
#include <map>
#include <algorithm>
using namespace std;

//#define printf(...);
#define I(x) x; cin >> x;
#define L(qq,m) for (int qq=0;qq<(m);qq++)
#define L0(qq,ss,m) for (int qq=(ss);qq<(m);qq++)
#define Ld(qq,ss,ff,d) for (int qq=(ss);qq>=(ff);qq+=(d))

typedef pair<int, int> pii;

inline int d(pii a, pii b) {
return abs(b.first - a.first) + abs(b.second - a.second);
}

int sd(vector<pii>& ns, pii p) {
int s = 0;
for (pii& pi : ns) s += d(pi, p);
return s;
}

int dsd(vector<pii>& ns, pii p, int dx, int dy) {
return sd(ns, make_pair(p.first + dx, p.second + dy)) - sd(ns, p);
}

int main() {
int n, c = 0;
while (cin >> n) {
if (n == 0) break;
vector<pii> ns(n);
int xmax = 0, xmin = 10000000, ymax = 0, ymin = 10000000;
L(i, n) {
int x, y;
cin >> x >> y;
xmin = min(xmin, x);
xmax = max(xmax, x);
ymin = min(ymin, y);
ymax = max(ymax, y);
ns[i] = make_pair(x, y);
}

vector<pii> nsx(ns);
vector<pii> nsy(ns);
sort(nsx.begin(), nsx.end(), [](pii a, pii b) { return a.first < b.first; });
sort(nsy.begin(), nsy.end(), [](pii a, pii b) { return a.second < b.second; });

//for (auto a : nsx) { printf("%d, ", a.first); } printf("\n");
//for (auto a : nsy) { printf("%d, ", a.second); } printf("\n");
//printf("--------\n");

int xb = 10000000, yb = 10000000;
int xe = 0, ye = 0;

for (auto& p : nsx) {
int x = p.first;
int dxb = dsd(ns, p, -1, 0);
int dxf = dsd(ns, p, 1, 0);
//printf("  x=%d dxb=%d dxf=%d\n", x, dxb, dxf);
if (dxb >= 0 && dxf == 0) xb = min(x, xb);
else if (dxf >= 0 && dxb == 0) xe = max(x, xe);
else if (dxf > 0 && dxb > 0) xb = xe = x;
}

for (auto& p : nsx) {
int y = p.second;
int dyb = dsd(ns, p, 0, -1);
int dyf = dsd(ns, p, 0, 1);
//printf("  y=%d dyb=%d dyf=%d\n", y, dyb, dyf);
if (dyb >= 0 && dyf == 0) yb = min(y, yb);
else if (dyf >= 0 && dyb == 0) ye = max(y, ye);
else if (dyf > 0 && dyb > 0) yb = ye = y;
}

//printf("x=[%d, %d], y=[%d, %d]\n", xb, xe, yb, ye);
cout << "Case " << (++c) << ": (" << xb << "," << yb << ") " << sd(ns, make_pair(xb, yb)) << endl;

#if 0
printf("     | ");
L0(x, xmin-10, xmax+10) {
printf("%4d ", x);
}

printf("\n");
L0(y, ymin-10, ymax+10) {
printf("%4d | ", y);
L0(x, xmin-10, xmax+10) {
if (std::find(ns.begin(), ns.end(), make_pair(x, y)) != ns.end())
printf("*%3d ", sd(ns, make_pair(x, y)));
else
printf("%4d ", sd(ns, make_pair(x, y)));
}
printf("\n");
}
break;
#endif
}
}
/*

minimize S(x0, y0)
S = sum (|x - x0| + |y - y0|)  for each point (x, y)
dS/dx = sum (number of points to the left  - number of points to the right)
dS/dy = sum (number of points above        - number of points below)

dx, dy = -1 or 1

number of points on left/right/above/below is monotonic --> local minimum is global minimum

Find a range of x0 where dS/dx = 0, also for y0 where dS/dy = 0 independently

Output smallest (x0, y0)

*/
```