#include <bits/stdc++.h>
using namespace std;
const int N = 505;
const double eps = 1e-8, pi = acos(-1.);
int sign(double x) { return (x > eps) - (x < -eps); }
struct P {
  double x, y;
  P() {}
  P(double x, double y) : x(x), y(y) {}
  void read() { cin >> x >> y; }
  void print() { cout << x << " " << y << "\n"; }
  P operator+(const P &c) const { return P(x + c.x, y + c.y); }
  P operator-(const P &c) const { return P(x - c.x, y - c.y); }
  P operator*(const double &c) const { return P(x * c, y * c); }
  P operator/(const double &c) const { return P(x / c, y / c); }
  int quad() const { return sign(y) > 0 || (sign(y) == 0 && sign(x) >= 0); }
  P rot90() { return P(-y, x); }
  P rot(double a) {
    return P(cos(a) * x - sin(a) * y, cos(a) * y + sin(a) * x);
  }
  double len2() { return x * x + y * y; }
  double len() { return sqrt(len2()); }
  P norm() { return *this / len(); }
};
struct P3 {
  double x, y, z;
  P3() {}
  P3(double x, double y, double z) : x(x), y(y), z(z) {}
  void read() { cin >> x >> y >> z; }
  P3 operator+(const P3 &c) const { return P3(x + c.x, y + c.y, z + c.z); }
  P3 operator-(const P3 &c) const { return P3(x - c.x, y - c.y, z - c.z); }
  P3 operator*(const double &c) const { return P3(x * c, y * c, z * c); }
  P3 operator/(const double &c) const { return P3(x / c, y / c, z / c); }
  double len2() { return x * x + y * y + z * z; }
  double len() { return sqrt(len2()); }
};
double det(P a, P b) { return a.x * b.y - a.y * b.x; }
double dot(P a, P b) { return a.x * b.x + a.y * b.y; }
double det(P o, P a, P b) { return det(a - o, b - o); }
double dot(P o, P a, P b) { return dot(a - o, b - o); }
struct O {
  P o;
  double r;
  O() {}
  O(P o, double r) : o(o), r(r) {}
  void read() {
    o.read();
    cin >> r;
  }
};
struct L {
  P a, b;
  L() {}
  L(P a, P b) : a(a), b(b) {}
  L(double a, double b, double c) {
    if (sign(a) == 0) {
      this->a = P(0, -c / b);
      this->b = P(sign(b), -c / b);
    } else if (sign(b) == 0) {
      this->a = P(-c / a, 0);
      this->b = P(-c / a, -sign(a));
    } else {
      if (sign(c) != 0) {
        int x = sign(c) * sign(det(P(-c / a, 0), P(0, -c / b)));
        if (x == 1)
          this->a = P(-c / a, 0), this->b = P(0, -c / b);
        else
          this->a = P(0, -c / b), this->b = P(-c / a, 0);
      } else {
        this->a = P(0, 0);
        this->b = P(sign(b), sign(b) * (-a / b));
      }
    }
  }
  bool includer(const P &p) const { return sign(det(b - a, p - a)) > 0; }
  L push(double len) {
    P det = (b - a).rot90().norm() * len;
    return L(a + det, b + det);
  }
};
bool tanCP(O &c, P &p0, P &p1, P &p2) {
  double x = (p0 - c.o).len2(), d = x - c.r * c.r;
  if (d < eps) return 0;
  P p = (p0 - c.o) * (c.r * c.r / x);
  P det = ((p0 - c.o) * (-c.r * sqrt(d) / x)).rot90();
  p1 = c.o + p + det;
  p2 = c.o + p - det;
  return 1;
}
double disToL(L l, P p) { return fabs(det(l.a, p, l.b) / (l.b - l.a).len()); }
double disToS(L l, P p) {
  return sign(dot(l.a, p, l.b)) * sign(dot(l.b, p, l.a)) == 1
             ? disToL(l, p)
             : min((p - l.a).len(), (p - l.b).len());
}
P isLL(L l1, L l2) {
  double s1 = det(l2.b - l2.a, l1.a - l2.a);
  double s2 = -det(l2.b - l2.a, l1.b - l2.a);
  return (l1.a * s2 + l1.b * s1) / (s1 + s2);
}
P fermat(vector<P> p) {
  int n = (int)p.size();
  assert(n);
  if (n == 1) return p[0];
  if (n == 2) return (p[0] + p[1]) / 2;
  if (n == 3) {
    double a[3];
    for (int i = (0); i < (3); i++)
      a[i] = (p[(i + 2) % 3] - p[(i + 1) % 3]).len();
    for (int i = (0); i < (3); i++) {
      int j = (i + 1) % 3, k = (i + 2) % 3;
      if (sign(a[i] * a[i] - a[j] * a[j] - a[k] * a[k] - a[j] * a[k]) >= 0)
        return p[i];
    }
    if (det(p[0], p[1], p[2]) < 0) swap(p[1], p[2]);
    P q1 = (p[2] - p[0]).rot(pi / 3) + p[0];
    P q2 = (p[0] - p[1]).rot(pi / 3) + p[1];
    return isLL(L(q1, p[1]), L(q2, p[2]));
  }
  P ans(0, 0);
  for (int i = (0); i < (n); i++) ans = ans + p[i];
  ans = ans / n;
  double len = 0;
  for (int i = (0); i < (n); i++) len += (ans - p[i]).len();
  double t = 100;
  while (t > eps) {
    bool f = 1;
    while (f) {
      f = 0;
      for (int i = -1; i <= 1; i += 2) {
        for (int j = -1; j <= 1; j += 2) {
          P np(ans.x + i * t, ans.y + j * t);
          double k = 0;
          for (int i = (0); i < (n); i++) k += (np - p[i]).len();
          if (sign(len - k) > 0) ans = np, len = k, f = 1;
        }
      }
    }
    t *= 0.5;
  }
  return ans;
}
P3 MinSphere(vector<P3> p) {
  int n = (int)p.size();
  assert(n);
  double t = 1;
  P3 ans(0, 0, 0);
  for (int i = (0); i < (n); i++) ans = ans + p[i];
  ans = ans / n;
  while (t > eps) {
    int j = -1;
    double ret = -1;
    for (int i = (0); i < (n); i++) {
      double tmp = (p[i] - ans).len();
      if (ret < tmp) ret = tmp, j = i;
    }
    ans = ans + (p[j] - ans) * t;
    t *= 0.999;
  }
  return ans;
}
void solve() {
  int n;
  cin >> n;
  vector<P3> p(n);
  for (int i = (0); i < (n); i++) p[i].read();
  P3 ans = MinSphere(p);
  cout << ans.x << " " << ans.y << " " << ans.z << "\n";
}
int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(0);
  cout << setiosflags(ios::fixed);
  cout << setprecision(7);
  solve();
  return 0;
}
