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 <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <map>
#include <queue>
#include <set>
#include <tuple>
using namespace std;
typedef long long ll;
#define _ << " " <<
#define all(X) (X).begin(), (X).end()
#define len(X) (X).size()
#define Pii pair<int, int>
#define Pll pair<ll, ll>
#define Tiii tuple<int, int, int>
#define Tlll tuple<ll, ll, ll>

double eps = 1e-8;

struct point /* vec */ {
    double x, y;
    point operator+(const point &p) {
        return {x + p.x, y + p.y};
    }
    point operator-(const point &p) {
        return {x - p.x, y - p.y};
    }
};

struct line {
    // ax + by + c = 0
    double a, b, c;
};

struct circle {
    point p;
    double r;
};

double dot(point P, point Q) {
    return P.x*Q.x + P.y*Q.y;
}

double cross_2d(point P, point Q) {
    return P.x*Q.y - P.y*Q.x;
}

double points_distance(point A, point B, int deg) {
    point C = B - A;
    return pow(C.x*C.x + C.y*C.y, 0.5 * deg);
}

line line_2points(point P, point Q) {
    return {P.y - Q.y, Q.x - P.x, P.x*Q.y - P.y*Q.x};
}

point lines_intersection(line l, line m) {
    if (abs(l.a*m.b - l.b*m.a) < eps) {
        assert(-1);
    }
    return {- (l.b*m.c - l.c*m.b) / (l.b*m.a - l.a*m.b),
            - (l.a*m.c - l.c*m.a) / (l.a*m.b - l.b*m.a)};
}

bool line_same(line l, line m) {
    if (l.c * m.c == 0) {
        if (l.c == m.c) {
            if (l.b * m.b == 0) {
                if (l.b == m.b) return 1;
                else return 0;
            }
            else return l.a / l.b == m.a / m.b; 
        }
        else return 0;
    }
    else return l.a / l.c == m.a / m.c && l.b / l.c == m.b / m.c;
}

bool on_line(point P, point Q, point R) {
    if (P.x > Q.x) swap(P, Q);
    if (P.y > Q.y) swap(P.y, Q.y);
    return (P.x <= R.x && R.x <= Q.x && P.y <= R.y && R.y <= Q.y);
}

double point_line_distance(point P, line l) {
    return abs(l.a * P.x + l.b * P.y + l.c) / sqrt(l.a*l.a + l.b*l.b);
}

double point_segment_distance(point p1, point p2, point q) {
    if (dot(q - p1, p2 - p1) <= 0) return points_distance(p1, q, 1);
    else if (dot(q - p2, p1 - p2) <= 0) return points_distance(p2, q, 1);
    else return point_line_distance(q, line_2points(p1, p2));
}

double is_segments_intersect(point p1, point p2, point q1, point q2) {
    line s0 = line_2points(p1, p2);
    line s1 = line_2points(q1, q2);
    if (abs(s0.a*s1.b - s0.b*s1.a) < eps) {
        if (p1.x > p2.x) swap(p1, p2);
        if (p1.y > p2.y) swap(p1.y, p2.y);
        if (q1.x > q2.x) swap(q1, q2);
        if (q1.y > q2.y) swap(q1.y, q2.y);
        if (line_same(s0, s1)) {
            return (q1.x <= p2.x && p1.x <= q2.x && q1.y <= p2.y && p1.y <= q2.y);
        }
        else return 0;
    }
    return cross_2d(p2 - p1, q1 - p1) * cross_2d(p2 - p1, q2 - p1) < eps
        && cross_2d(q2 - q1, p1 - q1) * cross_2d(q2 - q1, p2 - q1) < eps;
}

vector<point> circles_intersection(circle A, circle B) {
    vector<point> ret;
    point X = A.p;
    B.p = B.p - A.p;
    A.p = {0, 0};

    if (points_distance(A.p, B.p, 2) - pow(A.r + B.r, 2) > eps) return ret;

    double K = (B.p.x*B.p.x + B.p.y*B.p.y + A.r*A.r - B.r*B.r) / 2;
    double SQ = (B.p.x*B.p.x + B.p.y*B.p.y)*A.r*A.r - K * K;
    double DS = points_distance(A.p, B.p, 2);
    //cerr << K _ SQ _ DS << endl;
    if (SQ < 0) return ret;
    if (abs(SQ) < eps) {
        ret.push_back({K*B.p.x / DS + X.x, K*B.p.y / DS + X.y});
        return ret;
    }
    ret.push_back({(K*B.p.x + B.p.y*sqrt(SQ)) / DS + X.x,
                   (K*B.p.y - B.p.x*sqrt(SQ)) / DS + X.y});
    ret.push_back({(K*B.p.x - B.p.y*sqrt(SQ)) / DS + X.x,
                   (K*B.p.y + B.p.x*sqrt(SQ)) / DS + X.y});
    return ret;
}
 
int main() {
    cout << fixed << setprecision(10);
    circle A, B;
    cin >> A.p.x >> A.p.y >> A.r;
    cin >> B.p.x >> B.p.y >> B.r;
    vector<point> vec = circles_intersection(A, B);
    point p0 = vec[0], p1 = vec[1 % vec.size()];
    if (p0.x > p1.x) swap(p0, p1);
    if (p0.x == p1.x && p0.y > p1.y) swap(p0, p1);
    cout << p0.x _ p0.y _ p1.x _ p1.y << endl;
}