/*--------------------------------------------------------------*/
/* ACM ICPC 2009-2010, NEERC                                    */
/* Northern Subregional Contest                                 */
/* St Petersburg, October 17, 2009                              */
/*--------------------------------------------------------------*/
/* Problem F. Four Points                                       */
/*                                                              */
/* Original idea         Mikhail Dvorkin                        */
/* Problem statement     Yury Petrov                            */
/* Testset               Yury Petrov                            */
/*--------------------------------------------------------------*/
/* Solution                                                     */
/*                                                              */
/* Author                Sergey Kopeliovich                     */
/*--------------------------------------------------------------*/
 
#include <cmath>
#include <cstdlib>
#include <cstdio>

#include <iostream>
#include <algorithm>

#ifndef M_PI
#  define M_PI 3.14159265358979323846
#endif

using namespace std;

#define forn(i, n) for (int i = 0; i < (int)(n); i++)

typedef double dbl;

const dbl inf = 1e100;
const dbl eps = 1e-4;

struct pnt
{
  dbl x, y;

  pnt() { }
  pnt( dbl a ) { x = cos(a), y = sin(a); }
  pnt( dbl _x, dbl _y ) : x(_x), y(_y) { }

  pnt operator - ( pnt p ) { return pnt(x - p.x, y - p.y); }
  dbl operator * ( pnt p ) { return x * p.x + y * p.y; }
  dbl operator ^ ( pnt p ) { return x * p.y - y * p.x; }

  bool operator == ( pnt p ) { return fabs(x - p.x) < eps && fabs(y - p.y) < eps; }
  void out() { printf("%.20lf %.20lf\n", x, y); }

  dbl d() { return hypot(x, y); }
};

pnt p[4];
dbl F[2], Fmi[2], Fma[2];

dbl Calc( dbl ang )
{
  forn(t, 2)
  {
    pnt v(ang);
    dbl mi = inf, ma = -inf, x;
    forn(i, 4)
    {
      x = v * p[i];
      mi = min(mi, x);
      ma = max(ma, x);
    }
    F[t] = fabs(ma - mi);
    Fmi[t] = mi;
    Fma[t] = ma;
    ang += M_PI / 2;
  }
  return fabs(F[0] - F[1]);
}

dbl Search( dbl l, dbl r )
{
  const int N = 1000;

  if (r - l < 1e-12)
    return (l + r) * 0.5;

  dbl rx = 0, res = inf;
  dbl e = (r - l) / N;
  forn(i, N)
  {
    dbl x = l + (i + 0.5) * e;
    dbl tmp = Calc(x);

    if (tmp < res)
      res = tmp, rx = x;
  }
  return Search(rx - e, rx + e);
}

struct line
{
  dbl a, b, c;

  line() { }
  line( dbl ang, dbl val )
  {
    pnt v(ang);
    a = v.x;
    b = v.y;
    c = -val;
  }
};

pnt Intr( line L1, line L2 )
{
  pnt res;
  res.x = -(L1.c * L2.b - L2.c * L1.b) / (L1.a * L2.b - L2.a * L1.b);
  res.y = (L1.c * L2.a - L2.c * L1.a) / (L1.a * L2.b - L2.a * L1.b);
  return res;
}

int IsInSeg( pnt p, pnt a, pnt b )
{
  if (a == p || b == p)
    return 0;
  return 
    fabs((a - p) ^ (b - p)) < eps * (a - p).d() * (b - p).d() &&
    min(a.x, b.x) - eps < p.x && p.x < max(a.x, b.x) + eps &&
    min(a.y, b.y) - eps < p.y && p.y < max(a.y, b.y) + eps;
}

int main()
{
//  freopen("four.in", "r", stdin);
//  freopen("four.out", "w", stdout);

  forn(i, 4)
    scanf("%lf%lf", &p[i].x, &p[i].y);

  int M = 10;
  forn(i, M)
  {
    dbl ang = Search(M_PI / M * i, M_PI / M * (i + 1));
    if (Calc(ang) > eps)
      continue;

    line L1(ang, Fmi[0]);
    line L2(ang, Fma[0]);
    line M1(ang + M_PI / 2, Fmi[1]);
    line M2(ang + M_PI / 2, Fma[1]);

    pnt res[4];
    res[0] = Intr(L1, M1);
    res[1] = Intr(L1, M2);
    res[2] = Intr(L2, M2);
    res[3] = Intr(L2, M1);

    int good = 0;
    forn(i, 4)
    {
      good = 0;
      forn(j, 4)
        if (IsInSeg(p[i], res[j], res[(j + 1) & 3]))
          good = 1;
      if (!good)
        break;
    }
    if (good)
    {
      forn(i, 4)
        res[i].out();
      exit(0);
    }
  }
  forn(i, 4)
    puts("0 0");
  return 0;
}
