Problem: Read a set of coordinates of three different points P1 (x1, y1), P2 (x2, y2), Q (xq, yq) on the plane, and line symmetry with point Q with the straight line passing through point P1 point P2 as the axis of symmetry. Create a program that outputs the point R (x, y) at the position of. Note that the point Q is not on its axis of symmetry.

<image>



input

The input consists of multiple datasets. Each dataset is given in the following format:


x1, y1, x2, y2, xq, yq


x1, y1, x2, y2, xq, yq (real numbers between -100 and 100) are given on one line separated by commas.

The number of datasets does not exceed 50.

output

Print x, y on a single line, separated by blanks, for each dataset. The output may contain an error of 0.0001 or less in real numbers.

Example

Input

1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0


Output

1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;

const double EPS = 1e-8, PI = acos(-1);

inline bool eq(double a, double b) {
  return fabs(b - a) < EPS;
}

struct Point {
  double x, y;
  Point() {}
  Point(double x, double y) : x(x), y(y) {}
  Point operator+(const Point &b) const {
    return Point(x + b.x, y + b.y);
  }
  Point operator-(const Point &b) const {
    return Point(x - b.x, y - b.y);
  }
  Point operator*(const double b) const {
    return Point(x * b, y * b);
  }
  Point operator*(const Point &b) const {
    return Point(x * b.x - y * b.y, x * b.y + y * b.x);
  }
  Point operator/(const double b) const {
    return Point(x / b, y / b);
  }
  bool operator<(const Point &b) const {
    return x != b.x ? x < b.x : y < b.y;
  }
  bool operator==(const Point &b) const {
    return eq(x, b.x) && eq(y, b.y);
  }
  double norm() {
    return x * x + y * y;
  }
  double arg() {
    return atan2(x, y);
  }
  double abs() {
    return sqrt(norm());
  }
  Point rotate(double theta) {
    return Point(cos(theta) * x - sin(theta) * y, sin(theta) * x + cos(theta) * y);
  }
  Point rotate90() {
    return Point(-y, x);
  }
  friend ostream &operator<<(ostream &os, Point &p) {
    return os << "(" << p.x << "," << p.y << ")";
  }
  friend istream &operator>>(istream &is, Point &a) {
    return is >> a.x >> a.y;
  }
};

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

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

struct Line {
  Point a, b;

  Line(){};

  Line(Point a, Point b) : a(a), b(b){};

  friend ostream &operator<<(ostream &os, Line &p) {
    return os << "(" << p.a.x << "," << p.a.y << ") to (" << p.b.x << "," << p.b.y << ")";
  }

  friend istream &operator>>(istream &is, Line &a) {
    return is >> a.a.x >> a.a.y >> a.b.x >> a.b.y;
  }
};

Point Projection(const Line &l, const Point &p) {
  double t = dot(p - l.a, l.a - l.b) / (l.a - l.b).norm();
  return l.a + (l.a - l.b) * t;
}
Point Reflection(const Line &l, const Point &p) {
  return p + (Projection(l, p) - p) * 2.0;
}

int main() {
  double x_1, y_1, x_2, y_2, x_q, y_q;
  while (~scanf("%lf,%lf,%lf,%lf,%lf,%lf", &x_1, &y_1, &x_2, &y_2, &x_q, &y_q)) {
    Line l(Point(x_1, y_1), Point(x_2, y_2));
    Point r(x_q, y_q);
    Point p = Reflection(l, r);
    printf("%.10f %.10f\n", p.x, p.y);
  }
}