#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, 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;

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

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

typedef vector<Point> Polygon;

bool isParallel(Vector a, Vector b) {
    return equals(dot(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.p2 - s1.p1), (s2.p2 - s2.p1)), 0.0);
}

bool isOrthogonal(Vector a, Vector b) {
    return equals(cross(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 - s1.p1), (s2.p2 - s2.p1)), 0.0);
}

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) {
    Point projection = project(s, p);
    Vector toReflection = (projection - p) * 2.0;
    return p + toReflection; 
}

int ccw(Point p0, Point p1, Point p2) {
    Vector v1 = p1 - p0;
    Vector v2 = p2 - p0;

    // 反時計
    if (cross(v1, v2) > 0.0) return 1;
    // 時計
    if (cross(v1, v2) < 0.0) return -1;

    // p1, p2 が逆方向
    if (dot(v1, v2) < 0.0) return 2;

    // p1, p2 が同方向
    if (v1.abs() < v2.abs()) return -2;
    return 0;
}

bool intersect(Segment s1, Segment s2) {
    return (ccw(s1.p1, s1.p2, s2.p1) * ccw(s1.p1, s1.p2, s2.p2) <= 0
            && ccw(s2.p1, s2.p2, s1.p1) * ccw(s2.p1, s2.p2, s1.p2) <= 0);
}

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

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

    return getDistanceLP(s, p);
}

double getDistanceSS(Segment s1, Segment s2) {
    if (intersect(s1, s2)) {
        return 0.0;
    }

    return min(
        min(getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2)),
        min(getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2))
    );
}

double getDistancePP(Point p1, Point p2) {
    return (p2 - p1).abs();
}

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

    Vector hypo = s1.p2 - s1.p1;
    return s1.p1 + hypo * (d1 / (d1 + d2));
}

pair<Point, Point> getCircleSegmentCrossPoint(Circle c, Segment s) {
    Point projection = project(s, c.c);
    double dist = sqrt(c.r * c.r - (c.c - projection).norm());
    Vector base = s.p2 - s.p1;
    base = base / base.abs();
    Point a = projection + (base * dist);
    return make_pair(projection + (base * dist), projection - (base * dist));
}

void printPoints(Point p1, Point p2) {
    cout << p1.x << " " << p1.y << " " << p2.x << " " << p2.y << endl;
}

pair<Point, Point> getCircleCrossPoint(Circle c1, Circle c2) {
    double d = (c2.c - c1.c).abs();
    double a = acos((d * d + c1.r * c1.r - c2.r * c2.r) / (2 * d * c1.r));
    double t = atan2((c2.c - c1.c).y, (c2.c - c1.c).x);
    Point crossPoint1 = {c1.c.x + c1.r * cos(a + t), c1.c.y + c1.r * sin(a + t)};
    Point crossPoint2 = {c1.c.x + c1.r * cos(t - a), c1.c.y + c1.r * sin(t - a)};
    return make_pair(crossPoint1, crossPoint2);
}

int main() {
    cout << fixed << setprecision(11);
    double cx1, cy1, r1, cx2, cy2, r2;
    cin >> cx1 >> cy1 >> r1 >> cx2 >> cy2 >> r2;
    Point c1 = {cx1, cy1};
    Point c2 = {cx2, cy2};
    Circle circle1 = {c1, r1};
    Circle circle2 = {c2, r2};

    pair<Point, Point> crossPoints = getCircleCrossPoint(circle1, circle2);
    Point first = crossPoints.first;
    Point second = crossPoints.second;
    if (first.x < second.x) {
        printPoints(first, second);
    } else if (first.x > second.x) {
        printPoints(second, first);
    } else {
        if (first.y <= second.y) {
            printPoints(first, second);
        } else {
            printPoints(second, first);
        }
    }

    return 0;
}



Measured memory_bytes: 3660