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 <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>

using namespace std;
static const double eps = 1e-10;
static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;

bool equals(double a, double b)
{
    return(fabs(a - b) < eps);
}

class Point
{
public:
    double x, y;
    Point(double x = 0, double y = 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 a){ return(Point(a * x, a * y)); }
    Point operator / (double a){ return(Point(x / a, y / a)); }

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

    bool operator < (const Point& p) const
    {
        return(x != p.x ? x < p.x : y < p.y);
    }

    bool operator == (const Point& p) const
    {
        return(fabs(x - p.x) < eps && fabs(y - p.y) < eps);
    }
};
typedef Point Vector;


struct Segment
{
    Point p1, p2;
};
typedef Segment Line;

class Circle
{
public:
    Point c;
    double r;
    Circle(Point c = Point(), double r = 0.0) : c(c), r(r){}
};

double dot(Vector a, Vector b)
{
    return(a.x * b.x + a.y * b.y);
}

double cross(Vector a, Vector b)
{
    return(a.x * b.y - a.y * b.x);
}

Point project(Segment s, Point p)
{
    Vector base = s.p2 - s.p1;
    double r = dot(p - s.p1, base) / base.norm();
    return(s.p1 + base * r);
}

Point reflect(Segment s, Point p)
{
    return(p + (project(s, p) - p) * 2.0);
}

bool isOrthogonal(Vector a, Vector b)
{
    return(equals(dot(a, b), 0.0));
}

bool isOrthogonal(Point a1, Point a2, Point b1, Point b2)
{
    return(isOrthogonal(a1 - a2, b1 - b2));
}

bool isOrthogonal(Segment s1, Segment s2)
{
    return(equals(dot(s1.p2 - s2.p1, s2.p2 - s2.p1), 0.0));
}

bool isParallel(Vector a, Vector b)
{
    return(equals(cross(a, b), 0.0));
}

bool isParallel(Point a1, Point a2, Point b1, Point b2)
{
    return(isParallel(a1 - a2, b1 - b2));
}

bool isParallel(Segment s1, Segment s2)
{
    return(equals(cross(s1.p1 - s1.p1, s2.p2 - s2.p1), 0.0));
}

int ccw(Point p0, Point p1, Point p2)
{
    Vector a = p1 - p0;
    Vector b = p2 - p0;
    if (cross(a, b) > eps)
    {
        return(COUNTER_CLOCKWISE);
    }
    if (cross(a, b) < -eps)
    {
        return(CLOCKWISE);
    }
    if (dot(a, b) < -eps)
    {
        return(ONLINE_BACK);
    }
    if (a.norm() < b.norm())
    {
        return(ONLINE_FRONT);
    }
    return(ON_SEGMENT);
}


double arg(Vector p)
{
    return(atan2(p.y, p.x));
}

Vector polar(double a, double r)
{
    return(Point(cos(r) * a, sin(r) * a));
}

pair<Point, Point> getCrossPoints(Circle c1, Circle c2)
{
    double d = (c1.c - c2.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)));
}

void solve()
{
    cin.tie(0);
    ios::sync_with_stdio(false);

    Circle c1, c2;
    cin >> c1.c.x >> c1.c.y >> c1.r >> c2.c.x >> c2.c.y >> c2.r;
    pair<Point, Point> pp = getCrossPoints(c1, c2);
    if (pp.first < pp.second)
    {
        printf("%.10f %.10f %.10f %.10f\n", pp.first.x, pp.first.y, pp.second.x, pp.second.y);
    }
    else
    {
        printf("%.10f %.10f %.10f %.10f\n", pp.second.x, pp.second.y, pp.first.x, pp.first.y);
    }
}

int main()
{
    solve();
    return(0);
}