/*--------------------------------------------------------------*/
/* 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 = 1e-8;

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]);
}

const int iter = 10;
const int num = 1000;
const int lim = 100;

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> cur;
  cur.push_back(0.0);
  double w = M_PI * 2;
  for (int i = 0; i < iter; i++)
  {
    vector <pair <double, double> > res;
    for (int i = 0; i < (int)cur.size(); i++)
      for (int j = 0; j < num; j++)
      {
        double a = cur[i] + w * (j + 0.5 - 0.5 * num) / num;
        double fa = f(a);
        if (fa >= 0)
          res.push_back(make_pair(abs(log(fa)), a));
      }
    sort(res.begin(), res.end());
    cur.clear();
    for (int i = 0; i < (int)res.size() && i < lim; i++)
      cur.push_back(res[i].second);
    w /= num;
  }
  if (cur.size() > 0 && fabs(f(cur[0]) - 1.0) < eps2)
    for (int i = 0; i < 4; i++)
      printf("%.7lf %.7lf\n", res[i].x, res[i].y);
  else
    for (int i = 0; i < 4; i++)
      puts("0 0");

  return 0;
}
