Problem: For given two circles $c1$ and $c2$, print the coordinates of the cross points of them.

Constraints

* The given circle have at least one cross point and have different center coordinates.
* $-10,000 \leq c1x, c1y, c2x, c2y \leq 10,000$
* $1 \leq c1r, c2r \leq 10,000$

Input

The input is given in the following format.

$c1x\; c1y\; c1r$
$c2x\; c2y\; c2r$


$c1x$, $c1y$ and $c1r$ represent the coordinate and radius of the first circle. $c2x$, $c2y$ and $c2r$ represent the coordinate and radius of the second circle. All input values are given in integers.

Output

Print the coordinates ($x1$, $y1$) and ($x2$, $y2$) of the cross points $p1$ and $p2$ respectively in the following rules.

* If there is one cross point, print two coordinates with the same values.
* Print the coordinate with smaller $x$ first. In case of a tie, print the coordinate with smaller $y$ first.



The output values should be in a decimal fraction with an error less than 0.000001.

Examples

Input

0 0 2
2 0 2


Output

1.00000000 -1.73205080 1.00000000 1.73205080


Input

0 0 2
0 3 1


Output

0.00000000 2.00000000 0.00000000 2.00000000

Solution (in CPP):

Solution:
/* Header {{{ */
#include <bits/stdc++.h>
using namespace std;

typedef long long readtype;
typedef long long var;
typedef long double let;

readtype read() {
  readtype a = 0, c = getchar(), s = 0;
  while (!isdigit(c)) s |= c == '-', c = getchar();
  while (isdigit(c)) a = a * 10 + c - 48, c = getchar();
  return s ? -a : a;
}

#ifdef LOCAL_LOGGER
#define logger(...) fprintf(stderr, __VA_ARGS__)
#define abortif(v, ...) if (v) {logger("Error in Line %d, Function '%s()'.\nInfo: ", __LINE__, __FUNCTION__); logger(__VA_ARGS__); exit(0);}
#else
#define logger(...);
#define abortif(v, ...);
#endif
/* }}} */

const let eps = 1e-8;

int sign(let x) { return (x < -eps) ? -1 : (x > eps ? 1 : 0); }

struct Point {
  let x, y;
  let dist() {
    return sqrt(x * x + y * y);
  }
  Point Rotate(let sink, let cosk) {
    return (Point) {
      x * cosk - y * sink, x * sink + y * cosk
    };
  }
  Point Rotate(Point v) {
    let z = v.dist();
    return Rotate(v.y / z, v.x / z);
  }
  friend Point operator + (Point a, Point b) {
    return (Point) {a.x + b.x, a.y + b.y};
  }
  friend Point operator - (Point a, Point b) {
    return (Point) {a.x - b.x, a.y - b.y};
  }
  Point operator ~ () {
    return (Point) {x, -y};
  }
  friend bool operator < (Point a, Point b) {
    if (sign(a.x - b.x) == 0) return sign(a.y - b.y) < 0;
    return sign(a.x - b.x) < 0;
  }
  void EchoWith(char c) {
    printf("%.8Lf %.8Lf", x, y);
    putchar(c);
  }
};

typedef Point Vec;

struct Circle {
  Point o;
  let r;
  friend pair<Point, Point> Cross(Circle a, Circle b) {
    Vec v = b.o - a.o;
    let r1 = a.r, r2 = b.r, d = (b.o - a.o).Rotate(~v).x;
    if (sign(r1 + r2 - d) == 0) {
      Point p = ((Point) {r1, 0}).Rotate(v) + a.o;
      return make_pair(p, p);
    }

    let x = d / 2 + (r1 * r1 - r2 * r2) / (2 * d),
        y = sqrt(r1 * r1 - x * x);
    Point p1 = ((Point) {x, y}).Rotate(v) + a.o, 
          p2 = ((Point) {x, -y}).Rotate(v) + a.o;
    if (p2 < p1) swap(p1, p2);
    return make_pair(p1, p2);
  }
};

Point ReadPoint() {
  Point p;
  scanf("%Lf%Lf", &p.x, &p.y);
  return p;
}

Circle ReadCirle() {
  let c;
  Point p = ReadPoint();
  scanf("%Lf", &c);
  return (Circle) {p, c};
}

int main() {
// #ifndef ONLINE_JUDGE
//   freopen("CGL_7_E.in", "r", stdin);
//   freopen("CGL_7_E.out", "w", stdout);
// #endif
// #ifdef LOCAL_LOGGER
//   freopen("CGL_7_E.log", "w", stderr);
// #endif
  Circle c1 = ReadCirle(), c2 = ReadCirle();
  pair<Point, Point> res = Cross(c1, c2);
  res.first.EchoWith(' '), res.second.EchoWith('\n');
  return 0;
}

/* ==== Makefile ==== {{{
CompileAndRun:
	make Compile
	make Run

Compile:
	g++ -o CGL_7_E CGL_7_E.cpp -g -Wall -DLOCAL_LOGGER

CompileUF:
	g++ -o CGL_7_E CGL_7_E.cpp -g -Wall -DLOCAL_LOGGER -fsanitize=undefined

Run:
	./CGL_7_E < CGL_7_E.in > CGL_7_E.out
==================
}}} */