#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)

   */