/* KSP 15-1-1
 * Narozeninovy dort
 *
 * Petr Baudis
 * Rocnik: 3
 * Skola: Ad Fontes
 */


/*
 * Vstup:
 * d N\n
 * x y\n * N
 *
 * Vystup:
 * xm ym\n
 *
 * Algoritmus:
 *
 * Pro zacatek, aby se nam se svickami rozume dobre pracovalo, udelame si z
 * nich vzdy vektor z daneho vrcholu ke svicce, o kterem si budeme pamatovat
 * jeho uhel a delku (vlastne jenom uhel, delka je nam celkem ukradena). Zivot
 * bude hned lehci a radostnejsi.
 *
 * Nejdrive si urcime, kam bude ktera svicka patrit. To udelame jednoduse tak,
 * ze si pro kazdou stranu u kazde svicky zmerime delku usecky, ktera spojuje
 * danou svicku se stranou a je na stranu kolma (tedy jakasi pseudovyska). U
 * kazde strany vybereme takovych svicek N/3 (protoze strany jsou 3). Tohle je
 * vlastne hledani dvou minim v poli, z toho nam zustane O(N).
 *
 * Nyni si pro kazdy bod vezmeme strany, ktere se v nem sbihaji, a u kazde si z
 * onech N/3 svicek vememe tu, jejiz vektor k vrcholu svira se stranou nejvetsi
 * uhel (to nam bude trvat O(N)). Uhly si prevedeme tak, aby byly mereny proti
 * pouze jedne ze stran (je jedno ktere), a spocitame stredni hodnotu - tedy
 * prumer. Pod timto uhlem si pak postavime z vrcholu poloprimku. Tyto dva
 * ukony uz nam budou trvat pouze O(1).
 *
 * Jeden z moznych bodu, ktery bude takovym "strednim" bodem dortu, se nyni
 * bude urcite nalezat uvnitr trojuhelniku, ktery vytvori poloprimky vedene z
 * jednotlivych vrcholu (tyto poloprimky jsou totiz vlastne rezy, o kterych je
 * z predchoziho popisu zrejme, ze splnuji podminky zadani - tedy jsme dosli k
 * vysledku postupem inverznim k zadani, nejdriv jsme tvorili rezy a bod, odkud
 * se maji delat, jsme urcili jejich prunikem). Staci tedy vybrat napriklad
 * prusecik dvou poloprimek - v praxi tak staci, kdyz pocitame s vrcholy dvema.
 * To vse opet jiz pouze v O(1).
 *
 * Casova narocnost je tedy suma sumarum O(N). Pametova narocnost je O(N),
 * protoze si musime pamatovat vsechny vrcholy, abychom v nich pak mohli najit
 * N/3 nejblizsich pro kazdou stranu.
 */


#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include "heap.h"

#define M_PI_3         1.04719755119659774615  /* pi/3 */

#define A 0
#define B 1
#define C 2
#define a 0
#define b 1
#define c 2

static int d, n;

/* strana protejsi k bodu se nikdy nepocita */

struct point {
  int x, y;
  double dists[3]; /* ke [stranam] */
  double angles[3][3]; /* ke [stranam] z [vrcholu] */
  int used;
};

static struct point *points;

/* setridene podle vzdalenosti od [strany] */
static heap *sdheaps[3];
/* maximalni uhel [strany] a [vrcholu] */
static int angles[3][3];

int
main() {
  int s, i;

  scanf("%d %d", &d, &n);

  points = calloc(n, sizeof(struct point));

  /* Nacist polohy, prevest na vektory apod. */
  for (i = 0; i < n; i++) {
    float x, y;
    double vect_len;
    double d_ofs;

    scanf("%f %f", &x, &y);

    /* Vrchol A */
    vect_len = sqrt(x*x + y*y);
    printf("A===> %f\n", vect_len);

    points[i].angles[c][A] = atan(y / x);
    points[i].dists[c] = y;
    points[i].angles[b][A] = M_PI_3 - points[i].angles[c][A];
    points[i].dists[b] = sin(points[i].angles[b][A]) * vect_len;
    d_ofs = d - sqrt(vect_len*vect_len - points[i].dists[b]*points[i].dists[b]);

    /* Vrchol B */
    x = d - x;
    vect_len = sqrt(x*x + y*y);
    printf("B===> %f %f %f\n", vect_len, y/x, atan(y/x));

    points[i].angles[c][B] = atan(y / x);
    points[i].angles[a][B] = M_PI_3 - points[i].angles[c][B];
    points[i].dists[a] = sin(points[i].angles[a][B]) * vect_len;

    /* Vrchol C */
    vect_len = sqrt(d_ofs*d_ofs + points[i].dists[b]*points[i].dists[b]);
    printf("C===> %f\n", vect_len);

    points[i].angles[b][C] = acos(d_ofs / vect_len);
    points[i].angles[a][C] = M_PI_3 - points[i].angles[b][C];

    printf("(%f,%f) [%d] %f\n  c -> %f   a -> %f   b -> %f\n  cA -> %f   cB -> %f\n  bA -> %f   bC -> %f\n  aB -> %f   aC -> %f\n",
	d - x, y, i, vect_len,
	points[i].dists[c], points[i].dists[a], points[i].dists[b],
	points[i].angles[c][A], points[i].angles[c][B],
	points[i].angles[b][A], points[i].angles[b][C],
	points[i].angles[a][B], points[i].angles[a][C]);
  }

  for (s = a; s <= c; s++) {
    int pt;

    /* Ulozit vzdalenosti pro kazdou stranu na hromadku */
    for (pt = 0; pt < n; pt++) {
      if (points[pt].used)
	continue;
      heap_add(&sdheaps[s], &points[pt], points[pt].dists[s]);
    }

    /* Z hromadky vzit N/3 a najit pro krajni vrcholy max. uhly */
    for (pt = 0; pt < n/3; pt++) {
      struct point *p = heap_fetch(&sdheaps[s]);

      heap_shift(&sdheaps[s]);

      p->used = 1;
      for (i = A; i <= C; i++)
        if (p->angles[s][i] > angles[s][i])
	  angles[s][i] = p->angles[s][i];
    }
  }

  /* Ve vrcholu A a B vzit prumer uhlu, spocitat souradnice pruniku vektoru */
  {
    double angle_A, angle_B;
    double p;
    double x = 0, y = 0;

    angle_A = (angles[c][A] + M_PI_3 - angles[b][A]) / 2;
    angle_B = (angles[c][B] + M_PI_3 - angles[a][B]) / 2;
    p = sin(angle_B) * d/sin(M_PI - angle_A - angle_B);
    printf("(%d) %f %f -> %f\n", d, angle_A, angle_B, p);
    x = sin(M_PI_2-angle_A) * p;
    y = cos(M_PI_2-angle_A) * p;


    printf("(%f,%f)\n", x, y);
  }

  return 0;
}