// The best single-level pattern: at a fixed level f, the 0/1 field b with period lattice Lam (index n,
// k ones) whose filtered error is smallest; no nesting across levels. Its exact error is
//   e^2 = (k/n - f)^2 + (1/n) sum_{p,q} (b_p - k/n)(b_q - k/n) K_Lam(q - p).
// We anneal b for every Hermite-normal-form lattice <(a,0),(c,d)> with n in [nmin, nmax] and k = the
// nearest counts to f n, and report the best. Comparing it with the floor at the same level says whether
// the remaining gap is the floor's weakness or the price of nesting (a dither's levels must nest).
//   cc -O3 -o binpat binpat.c -lm && ./binpat f nmin nmax moves seed < k5.txt
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
static int T; static int tdx[512], tdy[512]; static double tw[512];
static int Kn; static int kdx[2048], kdy[2048]; static double kw[2048];
static unsigned long long rs = 0x2545F4914F6CDD1DULL;
static double rnd(void) { rs ^= rs << 13; rs ^= rs >> 7; rs ^= rs << 17; return (rs >> 11) * (1.0 / 9007199254740992.0); }
static int A_, C_, D_;
static int coset(int x, int y) { int k = (int)floor((double)y / D_); y -= k * D_; x -= k * C_; x %= A_; if (x < 0) x += A_; return y * A_ + x; }
static double energy(const char *b, const double *KL, int n, int k, double f) {
  double m = (double)k / n, s = 0;
  for (int p = 0; p < n; p++) for (int q = 0; q < n; q++) s += (b[p] - m) * (b[q] - m) * KL[p * n + q];
  return (m - f) * (m - f) + s / n;
}
int main(int argc, char **argv) {
  double f = atof(argv[1]); int nmin = atoi(argv[2]), nmax = atoi(argv[3]); long moves = atol(argv[4]); rs += atoi(argv[5]);
  while (scanf("%d %d %lf", &tdx[T], &tdy[T], &tw[T]) == 3) T++;
  for (int a = 0; a < T; a++) for (int b = 0; b < T; b++) {
    int dx = tdx[b] - tdx[a], dy = tdy[b] - tdy[a], g = -1;
    for (int i = 0; i < Kn; i++) if (kdx[i] == dx && kdy[i] == dy) { g = i; break; }
    if (g < 0) { g = Kn++; kdx[g] = dx; kdy[g] = dy; kw[g] = 0; }
    kw[g] += tw[a] * tw[b];
  }
  double gbest = 1e9; int gn = 0, ga = 0, gc = 0, gd = 0, gk = 0;
  for (int n = nmin; n <= nmax; n++) {
    double *KL = malloc(sizeof(double) * n * n), *KC = malloc(sizeof(double) * n);
    char *b = malloc(n), *best = malloc(n); int *px = malloc(sizeof(int) * n), *py = malloc(sizeof(int) * n);
    int k0 = (int)floor(f * n);
    for (int a = 1; a <= n; a++) {
      if (n % a) continue;
      int d = n / a;
      for (int c = 0; c < a; c++) {
        A_ = a; C_ = c; D_ = d;
        for (int i = 0; i < n; i++) { px[i] = i % a; py[i] = i / a; }
        for (int i = 0; i < n; i++) KC[i] = 0;
        for (int i = 0; i < Kn; i++) KC[coset(kdx[i], kdy[i])] += kw[i];
        for (int p = 0; p < n; p++) for (int q = 0; q < n; q++) KL[p * n + q] = KC[coset(px[q] - px[p], py[q] - py[p])];
        for (int k = k0; k <= k0 + 1; k++) {
          if (k < 1 || k >= n) continue;
          memset(b, 0, n); for (int i = 0; i < k; i++) b[i] = 1;
          for (int i = n - 1; i > 0; i--) { int j = (int)(rnd() * (i + 1)); char t = b[i]; b[i] = b[j]; b[j] = t; }
          double e = energy(b, KL, n, k, f), eb = e; memcpy(best, b, n);
          double T0 = 1e-4, T1 = 1e-8; double m = (double)k / n;
          for (long s = 0; s < moves; s++) {
            double temp = T0 * pow(T1 / T0, (double)s / moves);
            int u = (int)(rnd() * n), v = (int)(rnd() * n); if (b[u] == b[v]) continue;
            // move a one from u to v: change of sum_{p,q} (b_p - m)(b_q - m) K
            if (!b[u]) { int t = u; u = v; v = t; }
            double ds = 0;
            for (int q = 0; q < n; q++) { if (q == u || q == v) continue; ds += 2 * (b[q] - m) * (KL[v * n + q] - KL[u * n + q]); }
            // terms among u, v themselves: before b_u=1,b_v=0; after b_u=0,b_v=1 (symmetric K: no change in the u-v cross terms or diagonals)
            double de = ds / n;
            if (de <= 0 || rnd() < exp(-de / temp)) { b[u] = 0; b[v] = 1; e += de; if (e < eb - 1e-15) { eb = e; memcpy(best, b, n); } }
          }
          double chk = energy(best, KL, n, k, f);
          if (fabs(chk - eb) > 1e-10) fprintf(stderr, "drift %g %g\n", chk, eb);
          if (chk < gbest) { gbest = chk; gn = n; ga = a; gc = c; gd = d; gk = k; }
        }
      }
    }
    free(KL); free(KC); free(b); free(best); free(px); free(py);
  }
  printf("f %.4f best single-level error^2 %.7f (n %d, k %d, period lattice (%d,0),(%d,%d))\n", f, gbest, gn, gk, ga, gc, gd);
  return 0;
}