#include <iostream>
#include <algorithm>
#include <string>
#include <cmath>
#include <sstream>
using namespace std;

template <class T, class U>
T lexical_cast(const U& from) {
  T to;
  stringstream ss;
  ss << from; ss >> to;
  return to;
}

typedef double D;
const D EPS = 1e-8;

struct P {
  D x, y;
  P() { }
  P(D x_, D y_) : x(x_), y(y_) { }
};

struct L {
  P a, b;
  L() { }
  L(P a_, P b_) : a(a_), b(b_) { }
};

P operator +(P a, P b) { return P(a.x + b.x, a.y + b.y); }
P operator -(P a, P b) { return P(a.x - b.x, a.y - b.y); }
P operator *(P a, D b) { return P(a.x * b, a.y * b); }
P operator /(P a, D b) { return P(a.x / b, a.y / b); }

int sig(D a, D b) {
  if(a < b - EPS) return -1;
  if(a > b + EPS) return +1;
  return 0;
}

D inp(P a, P b) { return a.x*b.x + a.y*b.y; }
D outp(P a, P b) { return a.x*b.y - a.y*b.x; }
D norm(P p) { return inp(p, p); }
D abs(P p) { return sqrt(norm(p)); }
P rot90(P p) { return P(-p.y, p.x); }

P vec(P from, P to) { return to - from; }

P projection(L l, P p) { // 直線lに対する点pの写像
  P a = vec(l.a, l.b);
  P b = vec(l.a, p);
  D t = inp(a, b) / norm(a);
  return l.a + a * t;
}
P reflection(L l, P p) { // 直線lに対する点pの反射
  return p + vec(p, projection(l, p)) * 2;
}

int main() {
  for(string S; cin >> S; ) {
    for(int i = 0; i < (int)S.size(); ++i) {
      if(S[i] == ',') S[i] = ' ';
    }
    istringstream iss(S);
    double x1, y1, x2, y2, xq, yq;
    iss >> x1 >> y1 >> x2 >> y2 >> xq >> yq;
    L l(P(x1, y1), P(x2, y2));
    P p(xq, yq);
    P q = reflection(l, p);
    cout.setf(ios::fixed);
    cout.precision(4);
    cout << q.x << ' ' << q.y << endl;
  }
}