#include <bits/stdc++.h>
struct vector {
  double data[3];
};
vector operator+(const vector& u, const vector& v) {
  return {
      {u.data[0] + v.data[0], u.data[1] + v.data[1], u.data[2] + v.data[2]}};
}
vector operator-(const vector& u, const vector& v) {
  return {
      {u.data[0] - v.data[0], u.data[1] - v.data[1], u.data[2] - v.data[2]}};
}
vector operator*(const vector& u, double o) {
  return {{u.data[0] * o, u.data[1] * o, u.data[2] * o}};
}
vector operator/(const vector& u, double o) {
  return {{u.data[0] / o, u.data[1] / o, u.data[2] / o}};
}
double sqr(double x) { return x * x; }
double distance(const vector& u, const vector& v) {
  return sqr(u.data[0] - v.data[0]) + sqr(u.data[1] - v.data[1]) +
         sqr(u.data[2] - v.data[2]);
}
std::istream& operator>>(std::istream& is, vector& v) {
  return is >> v.data[0] >> v.data[1] >> v.data[2];
}
std::ostream& operator<<(std::ostream& os, const vector& v) {
  return os << v.data[0] << ' ' << v.data[1] << ' ' << v.data[2];
}
double farthest(const vector& v, const std::vector<vector>& us) {
  double result = 0;
  for (const vector& u : us) {
    result = std::max(result, distance(v, u));
  }
  return result;
}
std::tuple<double, vector> solve(vector v, size_t dim,
                                 const std::vector<vector>& ps) {
  if (dim == 3) {
    return {farthest(v, ps), v};
  }
  const size_t limit = 80;
  double l = -10000;
  double r = 10000;
  for (size_t step = 0; step < limit; ++step) {
    const double ll = (l * 2 + r) / 3;
    v.data[dim] = ll;
    const auto [lres, lpos] = solve(v, dim + 1, ps);
    const double rr = (l + r * 2) / 3;
    v.data[dim] = rr;
    const auto [rres, rpos] = solve(v, dim + 1, ps);
    if (lres < rres) {
      r = rr;
    } else {
      l = ll;
    }
  }
  v.data[dim] = (l + r) / 2;
  return solve(v, dim + 1, ps);
}
int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
  std::cout.precision(12);
  size_t n;
  std::cin >> n;
  std::vector<vector> ps(n);
  for (size_t i = 0; i < n; ++i) {
    std::cin >> ps[i];
  }
  auto [result, pos] = solve({0, 0, 0}, 0, ps);
  std::cout << pos << '\n';
}
