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

#define EPS (1e-10)
#define equals(a, b) (fabs((a)-(b)) < EPS )

// Point, Vector class
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 k ){ return Point( x * k, y * k ); }

  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;

// Segment
struct Segment {
  Point p1, p2;
};
typedef Segment Line;

double norm( Point p ) {
  return p.x * p.x + p.y * p.y;
}

double abs( Point p ) {
  return sqrt( norm( p ) );
}

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

bool isOrthogonal( Vector a, Vector b ) {
  return equals( dot(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 );
}

bool isParallel( Vector a, Vector b ) {
  return equals( cross( 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 );
}

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

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

static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;

int ccw( Point p0, Point p1, Point p2 ) {
  Vector a = p1 - p0;
  Vector b = p2 - p0;
  if ( cross( a, b ) > EPS ) return COUNTER_CLOCKWISE;
  if ( cross( a, b ) < -EPS ) return CLOCKWISE;
  if ( dot( a, b ) < -EPS ) return ONLINE_BACK;
  if ( a.norm() < b.norm() ) return ONLINE_FRONT;
  return ON_SEGMENT;
}

bool isIntersect( 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 isIntersect( Segment s1, Segment s2 ) {
  return isIntersect( s1.p1, s1.p2, s2.p1, s2.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;
}

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

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

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

double getDistance( Segment s1, Segment s2 ) {
  if ( isIntersect( 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 ) ));
}


int main() {
    string line;
    while ( getline( cin, line ) ) {
        replace( line.begin(), line.end(), ',', ' ' );
        istringstream is( line );
        double x1, y1, x2, y2, xq, yq;
        is >> x1 >> y1 >> x2 >> y2 >> xq >> yq;
        Segment s = { Point( x1, y1 ), Point( x2, y2 ) };
        Point q( xq, yq );
        Point r = reflect( s, q );
        printf( "%.6f %.6f\n", r.x, r.y );
    }
    return 0;
}

Measured memory_bytes: 0