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:
#include <bits/stdc++.h>
using namespace std;
#define EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS)

class Point {
public:
	double x, y;
	Point(double x = 0.0, double y = 0.0) :
			x(x), y(y) {
	}

	Point operator +(Point p) {
		return Point(x + p.x, y + p.y);
	}
	Point operator -(Point p) {
		return Point(x - p.x, y - p.y);
	}
	Point operator *(double k) {
		return Point(x * k, y * k);
	}
	Point operator /(double k) {
		return Point(x / k, y / k);
	}

	double norm() {
		return x * x + y * y;
	}
	double abs() {
		return sqrt(norm());
	}

	bool operator <(Point p) {
		return x != p.x ? x < p.x : y < p.y;
	}
	bool operator ==(Point p) {
		return equals(x, p.x) && equals(y, p.y);
	}
};
typedef Point Vector;

class Segment {
public:
	Point p1, p2;
	Segment(Point p1 = Point(), Point p2 = Point()) :
			p1(p1), p2(p2) {
	}
};
typedef Segment Line;

double dot(Vector v1, Vector v2) {
	return v1.x * v2.x + v1.y * v2.y;
}
double cross(Vector v1, Vector v2) {
	return v1.x * v2.y - v1.y * v2.x;
}
Vector unitVector(Vector v) {
	return v / v.abs();
}
Vector polar(double r, double a) {
	return Vector(r * cos(a), r * sin(a));
}
double arg(Vector v) {
	return atan2(v.y, v.x);
}
bool isOrthogonal(Vector v1, Vector v2) {
	return equals(dot(v1, v2), 0.0);
}
bool isOrthogonal(Segment s1, Segment s2) {
	return equals(dot(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}
bool isOrthogonal(Point l1, Point l2, Point m1, Point m2) {
	return isOrthogonal(l2 - l1, m2 - m1);
}
bool isParallel(Vector v1, Vector v2) {
	return equals(cross(v1, v2), 0.0);
}
bool isParallel(Segment s1, Segment s2) {
	return equals(cross(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}
bool isParallel(Point l1, Point l2, Point m1, Point m2) {
	return isParallel(l1 - l2, m1 - m2);
}

enum PositionSP {
	COUNTER_CLOCKWISE = -1,
	CLOCKWISE = 1,
	ONLINE_BACK = 2,
	ONLINE_FRONT = -2,
	ON_SEGMENT = 0
};
PositionSP ccw(Point p1, Point p2, Point p) {
	Vector a = p2 - p1, b = p - p1;
	if (cross(a, b) > EPS)
		return COUNTER_CLOCKWISE;
	else if (cross(a, b) < -EPS)
		return CLOCKWISE;
	else if (dot(a, b) < -EPS)
		return ONLINE_BACK;
	else if (a.norm() < b.norm())
		return ONLINE_FRONT;
	else
		return ON_SEGMENT;
}
bool intersect(Point p1, Point p2, Point p3, Point p4) {
	return (ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0
			&& ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0);
}
bool intersect(Segment s1, Segment s2) {
	return intersect(s1.p1, s1.p2, s2.p1, s2.p2);
}
Point intersection(Segment s1, Segment s2) {
	double d1 = abs(cross(s2.p2 - s2.p1, s1.p1 - s2.p1));
	double d2 = abs(cross(s2.p1 - s2.p2, s1.p2 - s2.p2));
	return s1.p1 + (s1.p2 - s1.p1) * d1 / (d1 + d2);
}
Point projection(Segment s, Point p) {
	Vector base = s.p2 - s.p1;
	double r = dot(p - s.p1, base) / base.norm();
	return s.p1 + base * r;
}

double distancePP(Point p1, Point p2) {
	return (p1 - p2).abs();
}
double distanceLP(Line l, Point p) {
	return abs(cross(l.p2 - l.p1, p - l.p1) / distancePP(l.p2, l.p1));
}
double distanceSP(Segment s, Point p) {
	if (dot(s.p2 - s.p1, p - s.p1) < 0.0)
		return distancePP(s.p1, p);
	else if (dot(s.p1 - s.p2, p - s.p2) < 0.0)
		return distancePP(s.p2, p);
	else
		return distanceLP(s, p);
}
double distanceSS(Segment s1, Segment s2) {
	if (intersect(s1, s2))
		return 0.0;
	else {
		return min(min(distanceSP(s1, s2.p1), distanceSP(s1, s2.p2)),
				min(distanceSP(s2, s1.p1), distanceSP(s2, s1.p2)));
	}
}

class Circle {
public:
	Point c;
	double r;
	Circle(Point c = Point(), double r = 0.0) :
			c(c), r(r) {
	}
};
pair<Point, Point> intersection(Circle c, Line l) {
	Point pr = projection(l, c.c);
	double base = sqrt(c.r * c.r - (pr - c.c).norm());
	Vector e = unitVector(l.p2 - l.p1);
	return make_pair(pr + e * base, pr - e * base);
}
pair<Point, Point> intersection(Circle c1, Circle c2) {
	double d = (c2.c - c1.c).abs();
	double a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
	double t = arg(c2.c - c1.c);
	return make_pair(c1.c + polar(c1.r, t + a), c1.c + polar(c1.r, t - a));
}

int main() {
	Circle c1, c2;
	cin >> c1.c.x >> c1.c.y >> c1.r;
	cin >> c2.c.x >> c2.c.y >> c2.r;
	pair<Point, Point> i = intersection(c1, c2);
	if (i.first < i.second) {
		cout << fixed << setprecision(10) << i.first.x << " " << i.first.y
				<< " ";
		cout << i.second.x << " " << i.second.y << endl;
	} else {
		cout << fixed << setprecision(10) << i.second.x << " " << i.second.y
				<< " ";
		cout << i.first.x << " " << i.first.y << endl;
	}
	return 0;
}