#include "validation.h"

#include <climits>
#include <cstdio>
#include <iomanip>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef vector<ll> vi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<vvvi> vvvvi;
#define all(v) (v).begin(), (v).end()

ll m               = 100;
const ll maxX      = 999'999'999;
ll bs              = maxX / m + 1;
const ld tolerance = 1e-6;

// Computes the correct answer, copied from reinier.cpp
ld getAnswer(const vi& Xl, const vi& Yl, const vi& Zl) {
	vvvvi X(m, vvvi(m, vvi(m))), Y(m, vvvi(m, vvi(m))), Z(m, vvvi(m, vvi(m)));
	for(int i = 0; i < Xl.size(); i++) {
		ll x = Xl[i], y = Yl[i], z = Zl[i];
		ll xb = x / bs, yb = y / bs, zb = z / bs;
		X[xb][yb][zb].push_back(x);
		Y[xb][yb][zb].push_back(y);
		Z[xb][yb][zb].push_back(z);
	}
	ld res = maxX * 3 + 3;
	for(ll i = 0; i < m - 1; i++) {
		for(ll j = 0; j < m - 1; j++) {
			for(ll k = 0; k < m - 1; k++) {
				vi xs, ys, zs;
				for(ll id = 0; id <= 1; id++) {
					for(ll jd = 0; jd <= 1; jd++) {
						for(ll kd = 0; kd <= 1; kd++) {
							xs.insert(xs.end(), all(X[i + id][j + jd][k + kd]));
							ys.insert(ys.end(), all(Y[i + id][j + jd][k + kd]));
							zs.insert(zs.end(), all(Z[i + id][j + jd][k + kd]));
						}
					}
				}
				for(ll a = 0; a < xs.size(); a++) {
					for(ll b = 0; b < xs.size(); b++) {
						if(a == b) continue;
						res = min(res, sqrt((ld)(xs[a] - xs[b]) * (xs[a] - xs[b]) +
						                    (ys[a] - ys[b]) * (ys[a] - ys[b]) +
						                    (zs[a] - zs[b]) * (zs[a] - zs[b])));
					}
				}
			}
		}
	}
	if(res > bs) {
		if(res == maxX * 3 + 3) {
			m--;
			bs = maxX / m + 1;
		} else {
			while(res > bs) {
				m--;
				bs = maxX / m + 1;
			}
		}
		return getAnswer(Xl, Yl, Zl);
	}
	return res;
}

int main(int argc, char** argv) {
	std::ifstream in(argv[1]);

	int n, testcase_seed, fixed_seed;
	in >> n >> testcase_seed;

	// Generate the team seed.
	// True random purpose, needs to be random every time
	std::random_device dev; // bt ignore
	auto random_seed = dev();

	auto seed = testcase_seed ^ random_seed;

	if(in >> fixed_seed) {
		seed = fixed_seed;
	}

	std::cerr << "Seed: " << seed << std::endl;

	// Generate the team input.
	vi X(n), Y(n), Z(n);

	{
		Generator g(seed);
		g.read_integer("n", n, n);
		g.newline();
		for(int i = 0; i < n; i++) {
			X[i] = g.read_integer("x", 0, maxX);
			g.space();
			Y[i] = g.read_integer("y", 0, maxX);
			g.space();
			Z[i] = g.read_integer("z", 0, maxX);
			g.newline();
		}
	}

	// Validate the team output.
	ld intended_answer = getAnswer(X, Y, Z);
	std::cerr << "Validator answer: " << std::setprecision(10) << intended_answer << std::endl;
	ld min_ans = min(intended_answer - tolerance, intended_answer * (1 - tolerance));
	ld max_ans = max(intended_answer + tolerance, intended_answer * (1 + tolerance));

	OutputValidator v(argc, argv);
	ld ans = v.read_float("ans", min_ans, max_ans);
	v.newline();
}