#include<stdio.h>
#include<iostream>
#include<fstream>
#include<iomanip>
#include<math.h>
using namespace std;

template <class T>
class _Point{
public:
	T x;
	T y;
	_Point(){}
	_Point(T _x, T _y) :x(_x), y(_y){}
	_Point(const _Point & v) :x(v.x), y(v.y){}

	const _Point operator + (const _Point & v)
	{
		return _Point(x+v.x,y+v.y);
	}
	const _Point operator - (const _Point & v)
	{
		return _Point(x - v.x, y - v.y);
	}
	T abs() const {
		return sqrt(x*x + y*y);
	}
	_Point unit() const{
		T len = abs();
		return _Point(x / len, y / len);
	}
	T operator*(const _Point &v) const
	{
		return x * v.x + y * v.y;
	}
	const _Point operator*(const T &len) const
	{
		return _Point(len * x, len * y);
	}
};
typedef double R;
typedef _Point<R> Point;
typedef Point Vector;

int main(){
	std::istream & c_in = cin;

	Point p, p1, p2;
	c_in >> p1.x >> p1.y >> p2.x >> p2.y;
	Vector P12(p2 - p1);
	Vector e12(P12.unit());

	int q;
	c_in >> q;
	for (int i = 0; i < q; ++i)
	{
		Point p;
		c_in >> p.x >> p.y;
		Point pp = p - p1;
		R projection = pp*e12;
		Vector b(projection*(e12.x), projection*(e12.y));
		Point X(p1 + b);
		Point Q(X);
		Vector px = X - p;
		Q = Q + px;
		cout << fixed << setprecision(10) << Q.x << " " << Q.y << endl;
	}
}
### Prompt

Your task is to create a cpp solution to the following problem:

For given three points p1, p2, p, find the reflection point x of p onto p1p2.

<image>

Constraints

* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.

Input


xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1


In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.

Output

For each query, print the coordinate of the reflection point x. The output values should be in a decimal fraction with an error less than 0.00000001.

Examples

Input

0 0 2 0
3
-1 1
0 1
1 1


Output

-1.0000000000 -1.0000000000
0.0000000000 -1.0000000000
1.0000000000 -1.0000000000


Input

0 0 3 4
3
2 5
1 4
0 3


Output

4.2400000000 3.3200000000
3.5600000000 2.0800000000
2.8800000000 0.8400000000

### Response

```cpp
#include<stdio.h>
#include<iostream>
#include<fstream>
#include<iomanip>
#include<math.h>
using namespace std;

template <class T>
class _Point{
public:
	T x;
	T y;
	_Point(){}
	_Point(T _x, T _y) :x(_x), y(_y){}
	_Point(const _Point & v) :x(v.x), y(v.y){}

	const _Point operator + (const _Point & v)
	{
		return _Point(x+v.x,y+v.y);
	}
	const _Point operator - (const _Point & v)
	{
		return _Point(x - v.x, y - v.y);
	}
	T abs() const {
		return sqrt(x*x + y*y);
	}
	_Point unit() const{
		T len = abs();
		return _Point(x / len, y / len);
	}
	T operator*(const _Point &v) const
	{
		return x * v.x + y * v.y;
	}
	const _Point operator*(const T &len) const
	{
		return _Point(len * x, len * y);
	}
};
typedef double R;
typedef _Point<R> Point;
typedef Point Vector;

int main(){
	std::istream & c_in = cin;

	Point p, p1, p2;
	c_in >> p1.x >> p1.y >> p2.x >> p2.y;
	Vector P12(p2 - p1);
	Vector e12(P12.unit());

	int q;
	c_in >> q;
	for (int i = 0; i < q; ++i)
	{
		Point p;
		c_in >> p.x >> p.y;
		Point pp = p - p1;
		R projection = pp*e12;
		Vector b(projection*(e12.x), projection*(e12.y));
		Point X(p1 + b);
		Point Q(X);
		Vector px = X - p;
		Q = Q + px;
		cout << fixed << setprecision(10) << Q.x << " " << Q.y << endl;
	}
}
```