#include "bits/stdc++.h"
using namespace std;
typedef long long LL;

const double EPS = 1e-10;
const int COUNTER_CLOCKWISE = 1;
const int CLOCKWISE = -1;
const int ONLINE_BACK = 2;
const int ONLINE_FRONT = -2;
const int ON_SEGMENT = 0;
const int IN = 2;
const int ON = 1;
const int OUT = 0;

typedef complex<double> Point;
typedef Point Vector;
struct Segment {
	Point p1, p2;
	Segment(Point p1, Point p2) :p1(p1), p2(p2) {}
};
typedef Segment Line;
struct Circle {
	Point c;
	double r;
	Circle(Point c = Point(), double r = 0.0) :c(c), r(r) {}
};
typedef vector<Point> Polygon;

inline double equals(double a, double b);
inline double dot(Vector a, Vector b);
inline double cross(Vector a, Vector b);
inline bool isOrthogonal(Vector a, Vector b);
inline bool isParallel(Vector a, Vector b);
Point project(Segment s, Point p);
Point reflect(Segment s, Point p);
int ccw(Point p0, Point p1, Point p2);
bool intersect(Segment s1, Segment s2);
bool intersect(Circle c, Line l);
bool intersect(Circle c1, Circle c2);
double getDistanceLP(Line l, Point p);
double getDistanceSP(Segment s, Point p);
double getDistance(Segment s1, Segment s2);
Point getCrossPoint(Segment s1, Segment s2);
pair<Point, Point> getCrossPoints(Circle c, Line l);
pair<Point, Point> getCrossPoints(Circle c1, Circle c2);
int contains(Polygon g, Point p);
Polygon andrewScan(Polygon s);

inline double equals(double a, double b) {
	return fabs(a - b) < EPS;
}
bool operator==(const Point &p1, const Point &p2) {
	return equals(p1.real(), p2.real()) && equals(p1.imag(), p2.imag());
}
inline double dot(Vector a, Vector b) {
	return a.real()*b.real() + a.imag()*b.imag();
}
inline double cross(Vector a, Vector b) {
	return a.real()*b.imag() - a.imag()*b.real();
}
inline bool isOrthogonal(Vector a, Vector b) {
	return equals(dot(a, b), 0.0);
}
inline bool isParallel(Vector a, Vector b) {
	return equals(cross(a, b), 0.0);
}
Point project(Segment s, Point p) {
	Vector base = s.p2 - s.p1;
	double r = dot(p - s.p1, base) / norm(base);
	return s.p1 + base*r;
}
Point reflect(Segment s, Point p) {
	return p + (project(s, p) - p)*2.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 (norm(a) < norm(b)) return ONLINE_FRONT;
	return ON_SEGMENT;
}
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);
}
bool intersect(Circle c, Line l) {
	return getDistanceLP(l, c.c) <= c.r;
}
bool intersect(Circle c1, Circle c2) {
	return abs(c1.c - c2.c) <= c1.r + c2.r;
}
double getDistanceLP(Line l, Point p) {
	return abs(cross(l.p2 - l.p1, p - l.p1) / abs(l.p2 - l.p1));
}
double getDistanceSP(Segment s, Point p) {
	if (dot(s.p2 - s.p1, p - s.p1) < 0.0) return abs(p - s.p1);
	if (dot(s.p1 - s.p2, p - s.p2) < 0.0) return abs(p - s.p2);
	return getDistanceLP(s, p);
}
double getDistance(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)));
}
Point getCrossPoint(Segment s1, Segment s2) {
	assert(intersect(s1, 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;
}
pair<Point, Point> getCrossPoints(Circle c, Line l) {
	assert(intersect(c, l));
	Vector pr = project(l, c.c);
	Vector e = (l.p2 - l.p1) / abs(l.p2 - l.p1);
	double base = sqrt(c.r*c.r - norm(pr - c.c));
	return make_pair(pr + e*base, pr - e*base);
}
pair<Point, Point> getCrossPoints(Circle c1, Circle c2) {
	assert(intersect(c1, c2));
	double d = abs(c1.c - c2.c);
	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 make_pair(c1.c + polar(c1.r, t + a), c1.c + polar(c1.r, t - a));
}
int contains(Polygon g, Point p) {
	int n = g.size();
	bool x = false;
	for (int i = 0; i < n; i++) {
		Point a = g[i] - p, b = g[(i + 1) % n] - p;
		if (abs(cross(a, b)) < EPS && dot(a, b) < EPS) return 1;
		if (a.imag() > b.imag()) swap(a, b);
		if (a.imag() < EPS && EPS<b.imag() && cross(a, b)>EPS) x = !x;
	}
	return x ? 2 : 0;
}
Polygon andrewScan(Polygon s) {
	Polygon u, l;
	if (s.size() < 3) return s;
	sort(s.begin(), s.end(), [](const Point &a, const Point &b) {return a.real() != b.real() ? a.real() < b.real() : a.imag() < b.imag(); });
	u.push_back(s[0]);
	u.push_back(s[1]);
	l.push_back(s[s.size() - 1]);
	l.push_back(s[s.size() - 2]);
	for (int i = 2; i < s.size(); i++) {
		for (int n = u.size(); n >= 2 && ccw(u[n - 2], u[n - 1], s[i]) != CLOCKWISE; n--) {
			u.pop_back();
		}
		u.push_back(s[i]);
	}
	for (int i = s.size() - 3; i >= 0; i--) {
		for (int n = l.size(); n >= 2 && ccw(l[n - 2], l[n - 1], s[i]) != CLOCKWISE; n--) {
			l.pop_back();
		}
		l.push_back(s[i]);
	}
	reverse(l.begin(), l.end());
	for (int i = u.size() - 2; i >= 1; i--) l.push_back(u[i]);
	return l;
}

int main() {
	int x, y;
	cin >> x >> y;
	Point p1(x, y);
	cin >> x >> y;
	Point p2(x, y);
	Segment s(p1, p2);
	int q;
	cin >> q;
	for (int i = 0; i < q; i++) {
		cin >> x >> y;
		Point p(x, y);
		Point a = reflect(s, p);
		printf("%.15lf %.15lf\n", a.real(), a.imag());
	}
}


Measured memory_bytes: 3268