/*--------------------------------------------------------------*/
/* 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                Yury Petrov                            */
/*--------------------------------------------------------------*/
 
#include <cstdio>
#include <cmath>
#include <cassert>
#include <algorithm>
#include <vector>

#ifndef M_PI
#  define M_PI 3.14159265358979323846
#endif

using namespace std;

struct vec
{
  double x, y;
  vec( double xx = 0, double yy = 0 ) : x(xx), y(yy) {}
  double operator * ( vec b ) { return x * b.x + y * b.y; }
  double operator ^ ( vec b ) { return x * b.y - y * b.x; }
  vec operator * ( double b ) { return vec(x * b, y * b); }
  vec operator + ( vec b ) { return vec(x + b.x, y + b.y); }
  vec operator - ( vec b ) { return vec(x - b.x, y - b.y); }
};

vec p[4], res[4];

const double inf = 1e100;
const double eps = 1.1e-6;
const double eps2 = 1.e-9;

double f( double a )
{
  vec d[2] = {vec(cos(a), sin(a)), vec(-sin(a), cos(a))};
  double mi[2] = {+inf, +inf}, ma[2] = {-inf, -inf};
  for (int i = 0; i < 2; i++)
    for (int j = 0; j < 4; j++)
    {
      double v = d[i] * p[j];
      mi[i] = min(mi[i], v);
      ma[i] = max(ma[i], v);
    }
  res[0] = d[0] * mi[0] + d[1] * mi[1];
  res[1] = d[0] * ma[0] + d[1] * mi[1];
  res[2] = d[0] * ma[0] + d[1] * ma[1];
  res[3] = d[0] * mi[0] + d[1] * ma[1];
  int cnt[4] = {0, 0, 0, 0};
  for (int i = 0; i < 4; i++)
    for (int j = 0; j < 2; j++)
    {
      double v = d[j] * p[i];
      cnt[i] += fabs(v - ma[j]) < eps;
      cnt[i] += fabs(v - mi[j]) < eps;
    }
  for (int i = 0; i < 4; i++)
    if (cnt[i] != 1)
      return -1;
  return (ma[1] - mi[1]) / (ma[0] - mi[0]);
}

double norm( double a )
{
  while (a > M_PI * 2)
    a -= M_PI * 2;
  while (a < 0)
    a += M_PI * 2;
  return a;
}

bool solve( double l, double r )
{
  if (f((l + r) * 0.5) < 0)
    return false;
  double d = eps2;
  while (f(l + d) < 0 || f(r - d) < 0)
    d *= 2;
  l += d, r -= d;
  double fl = f(l), fr = f(r);
  assert(fl >= 0 && fr >= 0);
  if (fl > fr)
    swap(l, r), swap(fl, fr);
  if (fl - eps2 > 1 || fr + eps2 < 1)
    return false;
  for (int it = 0; it < 40; it++)
  {
    double a = (l + r) * 0.5, fa = f(a);
    if (fa <= 1)
      l = a, fl = fa;
    else
      r = a, fr = fa;
  }
  for (int i = 0; i < 4; i++)
    printf("%.7lf %.7lf\n", res[i].x, res[i].y);
  return true;
}

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

  for (int i = 0; i < 4; i++)
  {
    assert(scanf("%lf%lf", &p[i].x, &p[i].y) == 2);
    assert(-1000 <= p[i].x && p[i].x <= 1000);
    assert(-1000 <= p[i].y && p[i].y <= 1000);
  }
  for (int i = 0; i < 4; i++)
    for (int j = 0; j < i; j++)
      for (int k = 0; k < j; k++)
        assert(((p[i] - p[k]) ^ (p[j] - p[k])) != 0);
  vector <double> a;
  for (int i = 0; i < 4; i++)
    for (int j = 0; j < 4; j++)
      if (i != j)
      {
        double t = atan2(p[j].y - p[i].y, p[j].x - p[i].x);
        a.push_back(norm(t));
        a.push_back(norm(t + M_PI / 2));
      }
  sort(a.begin(), a.end());
  a.push_back(a[0] + 2 * M_PI);
  for (int i = 0; i < (int)a.size() - 1; i++)
    if (solve(a[i], a[i + 1]))
      return 0;
  for (int i = 0; i < 4; i++)
    puts("0 0");

  return 0;
}
