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>
const double EPS =  1e-10;
#define equals(a, b) (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 * (Point p){
        return Point(x * p.x, y * p.y);
    }
    Point operator * (double r){
        return Point(x * r, y * r);
    }
    Point operator / (Point p){
        return Point(x / p.x, y / p.y);
    }
    Point operator / (double d){
        return Point(x / d, y / d);
    }

    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;

class Segment : public Point{
    public:
    Point p1, p2;
    Segment(Point p1_, Point p2_){
        p1 = p1_;
        p2 = p2_;
    }
    Segment(double a, double b, double c, double d){
        Point(a, b);
        Point(c, d);
    }
    
};

typedef Segment Line;

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

double dot(Point a, Point b){
    return a.x * b.x + a.y * b.y;
}
double cross(Point a, Point b){
    return a.x * b.y - a.y * b.x;
}
bool isOrthogonal(Point a, Point b){
    return equals(dot(a, b), 0.0);
}
bool isParallel(Point a, Point b){
    return equals(cross(a, b), 0.0);
}
bool isOrthogonal(Segment s1, Segment s2){
    return equals(dot(s1.p2 - s1.p1, s2.p2 - s1.p1), 0.0);
}
bool isParallel(Segment s1, Segment s2){
    return equals(cross(s1.p2 - s1.p1, s2.p2 - s1.p1), 0.0);
}

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

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

int ccw(Point p1, Point p2, Point p3){
    Vector a = p2 - p1;
    Vector b = p3 - p1;
    if( cross(a, b) > EPS ) return 1;
    else if( cross(a, b) < -EPS ) return -1;
    else if( dot(a, b) < -EPS ) return 2;
    else if( a.norm() < b.norm() ) return -2;
    //std::cout << std::fixed << std::setprecision(10) << ans.x << " " << ans.y << std::endl;
    else return 0;
}

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



double getDistance(Point a, Point b){
    return (a - b).abs();
}

double getDistanceLP(Line l, Point p){    
    return abs(cross(l.p2 - l.p1, p - l.p1)) / (l.p2 - l.p1).abs();
}

/*
bool intersect(Circle c, Line l){
    double d = getDistanceLP(l, c.c);
    std::cout << d << std::endl;
    if( (c.r - d) < EPS ){
        return 1;
    }else{
        return 0;
    }
}
*/

double getDistanceSP(Segment s, Point p){
    if(dot(s.p2 - s.p1, p - s.p1) < 0.0) return (p - s.p1).abs();
    if(dot(s.p1 - s.p2, p - s.p2) < 0.0) return (p - s.p2).abs();
    return getDistanceLP(s, p);
}

double getDistance(Segment s1, Segment s2){
    if( intersect(s1, s2) ) return 0.0;
    return std::min(std::min(getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2)), std::min(getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2)));
}

Point getCrossPoint(Segment s1, Segment s2){
    Vector base = s2.p2 - s2.p1;
    double d1 = abs(cross(base, s1.p1 - s2.p1));
    double d2 = abs(cross(base, s1.p2 - s2.p1));
    double t = d1 / (d1 + d2);
    return s1.p1 + (s1.p2 - s1.p1) * t;
}

std::pair<Point, Point> getCrossPoints(Circle c, Line l){
    //assert(intersect(c, l));
    Vector pr = project(l, c.c);
    Vector e = (l.p2 - l.p1) / (l.p2 - l.p1).abs();
    double base = sqrt(c.r * c.r - (pr - c.c).norm());
    return std::make_pair(pr + e * base, pr - e * base);

}

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

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

std::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 std::make_pair(c1.c + polar(c1.r, t+ a), c1.c + polar(c1.r, t-a));
     
}

int main(void){
    Circle c1, c2;
    std::cin >> c1.c.x >> c1.c.y >> c1.r;
    std::cin >> c2.c.x >> c2.c.y >> c2.r;

    std::pair<Point, Point> ans;
    
    ans = getCrossPoints(c1, c2);
    Point ans1, ans2;
    
    if(ans.first.x > ans.second.x){
        ans1 = ans.second;
        ans2 = ans.first;
    }else if(ans.first.x == ans.second.x){
        if(ans.first.y > ans.second.y){
            ans1 = ans.second;
            ans2 = ans.first;
        }else{
            ans1 = ans.first;
            ans2 = ans.second;
        }
    }else{
        ans1 = ans.first;
        ans2 = ans.second;
    }
    
    std::cout << std::fixed << std::setprecision(10) << ans1.x << " " << ans1.y\
    << " " << ans2.x << " " << ans2.y << std::endl;
        
        


    return 0;
}