// Задача "Адронные коллайдеры"
// 10-ая Всероссийская командная олимпиада школьников по программированию
// Автор задачи: Михаил Кевер
// Автор решения: Сергей Поромов, poromov@rain.ifmo.ru

import java.io.*;
import java.util.*;

public class hadron_sp implements Runnable {

	public static void main(String[] args) {
		new Thread(new hadron_sp()).run();
	}

	public void run() {
		try {
			Locale.setDefault(Locale.US);
			br = new BufferedReader(new FileReader(FILENAME + ".in"));
			out = new PrintWriter(FILENAME + ".out");
			solve();
			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	BufferedReader br;

	PrintWriter out;

	StringTokenizer st;

	String nextToken() throws IOException {
		while (st == null || !st.hasMoreTokens()) {
			st = new StringTokenizer(br.readLine());
		}
		return st.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	void myAssert(boolean e, String s) {
		if (!e) {
			throw new Error("Assertion failure " + s);
		}
	}

	private static final String FILENAME = "hadron";

	int[] x, y, r;

	double eps = 1e-9;

	int MAX = 1000;

	double getRad(double xx, double yy) {
		double l = (x[0] - xx) * (x[0] - xx) + (y[0] - yy) * (y[0] - yy);
		return Math.sqrt(l + r[0] * r[0]);
	}

	double[] getPoint(int i, int j) {
		double l = Math.sqrt((x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j])
				* (y[i] - y[j]));
		double tx = (r[j] * r[j] - r[i] * r[i] + l * l) / (2 * l);
		double xx = x[i] + (x[j] - x[i]) * tx / l;
		double yy = y[i] + (y[j] - y[i]) * tx / l;
		return new double[] { xx, yy };
	}

	double[] getLine(int i, int j, double xx, double yy) {
		double[] ret = new double[3];
		ret[0] = x[j] - x[i];
		ret[1] = y[j] - y[i];
		ret[2] = -ret[0] * xx - ret[1] * yy;
		return ret;
	}

	double[] inter(double[] a, double[] b) {
		double t = a[0] * b[1] - a[1] * b[0];
		return new double[] { (b[2] * a[1] - a[2] * b[1]) / t,
				(-b[2] * a[0] + a[2] * b[0]) / t };
	}

	public void solve() throws IOException {
		int n = nextInt();
		myAssert(1 <= n && n <= 3, "Wrong n");
		x = new int[n];
		y = new int[n];
		r = new int[n];
		for (int i = 0; i < n; i++) {
			x[i] = nextInt();
			y[i] = nextInt();
			r[i] = nextInt();
			myAssert(-MAX <= x[i] && x[i] <= MAX, "Wrong x");
			myAssert(-MAX <= y[i] && y[i] <= MAX, "Wrong y");
			myAssert(1 <= r[i] && r[i] <= MAX, "Wrong r");
		}
		myAssert(good(x, y, r), "Wrong circles");
		if (n == 1) {
			double xx = x[0] + r[0];
			double yy = y[0] + r[0];
			double l = (x[0] - xx) * (x[0] - xx) + (y[0] - yy) * (y[0] - yy);
			out.println(xx + " " + yy + " " + Math.sqrt(l + r[0] * r[0]));
			return;
		}
		if (n == 2) {
			double[] p = getPoint(0, 1);
			double rr = getRad(p[0], p[1]);
			out.println(p[0] + " " + p[1] + " " + rr);
			return;
		}
		double[][] lines = new double[3][3];
		int t = 0;
		for (int i = 0; i < n; i++) {
			for (int j = i + 1; j < n; j++) {
				double[] p = getPoint(i, j);
				lines[t++] = getLine(i, j, p[0], p[1]);
			}
		}
		double[] ans = null;
		ans = inter(lines[0], lines[1]);
		double rr = getRad(ans[0], ans[1]);
		out.println(ans[0] + " " + ans[1] + " " + rr);
	}

	static boolean good(int[] x, int[] y, int[] r) {
		for (int i = 0; i < x.length; i++) {
			for (int j = i + 1; j < x.length; j++) {
				int len = (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j])
						* (y[i] - y[j]);
				if (len <= (r[i] + r[j]) * (r[i] + r[j])) {
					return false;
				}
			}
		}
		if (x.length == 3) {
			int dx1 = x[1] - x[0];
			int dy1 = y[1] - y[0];
			int dx2 = x[2] - x[0];
			int dy2 = y[2] - y[0];
			if (dx1 * dy2 - dx2 * dy1 == 0) {
				return false;
			}
		}
		return true;
	}
}