#include<iostream>
#include<cstdio>
#include<cmath>

struct Point{
	long double X,Y;
	inline void read(){scanf("%Lf%LF",&X,&Y);}
	inline long double plength(){return X*X+Y*Y;}
	inline long double length(){return sqrtl(plength());}
	Point(){X=Y=0;}
	Point(long double X_,long double Y_){X=X_,Y=Y_;}
};
struct Line{
	Point A,B;
	inline void read(){A.read(),B.read();}
	Line(){}
	Line(const Point &A_,const Point &B_){A=A_,B=B_;}
};
typedef Point Vector;
inline Vector operator - (const Point &A,const Point &B){return Vector(A.X-B.X,A.Y-B.Y);}
inline long double operator ^ (const Point &A,const Point &B){return A.X*B.X+A.Y*B.Y;}
inline long double operator * (const Point &A,const Point &B){return A.X*B.Y-A.Y*B.X;}
inline Point operator + (const Point &A,const Vector &B){return Point(A.X+B.X,A.Y+B.Y);}
inline Vector operator * (const Vector &A,long double k){return Vector(A.X*k,A.Y*k);}

Line L;
Point P;

int Q;

inline long double sqr(long double k){return k*k;}

Point Projection(const Line &L,const Point &P){
	long double len=((P-L.A)^(L.B-L.A))/(L.B-L.A).plength();
	return L.A*(1-len)+L.B*len;
}

Point Reflection(const Line &L,const Point &P){
	Point projection=Projection(L,P);
	return projection+(projection-P);
}

int main(){
	L.read();
	scanf("%d",&Q);
	while (Q--){
		P.read();
		Point Ans=Reflection(L,P);
		printf("%.10Lf %.10Lf\n",Ans.X,Ans.Y);
	}
}


### Prompt

Generate 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<iostream>
#include<cstdio>
#include<cmath>

struct Point{
	long double X,Y;
	inline void read(){scanf("%Lf%LF",&X,&Y);}
	inline long double plength(){return X*X+Y*Y;}
	inline long double length(){return sqrtl(plength());}
	Point(){X=Y=0;}
	Point(long double X_,long double Y_){X=X_,Y=Y_;}
};
struct Line{
	Point A,B;
	inline void read(){A.read(),B.read();}
	Line(){}
	Line(const Point &A_,const Point &B_){A=A_,B=B_;}
};
typedef Point Vector;
inline Vector operator - (const Point &A,const Point &B){return Vector(A.X-B.X,A.Y-B.Y);}
inline long double operator ^ (const Point &A,const Point &B){return A.X*B.X+A.Y*B.Y;}
inline long double operator * (const Point &A,const Point &B){return A.X*B.Y-A.Y*B.X;}
inline Point operator + (const Point &A,const Vector &B){return Point(A.X+B.X,A.Y+B.Y);}
inline Vector operator * (const Vector &A,long double k){return Vector(A.X*k,A.Y*k);}

Line L;
Point P;

int Q;

inline long double sqr(long double k){return k*k;}

Point Projection(const Line &L,const Point &P){
	long double len=((P-L.A)^(L.B-L.A))/(L.B-L.A).plength();
	return L.A*(1-len)+L.B*len;
}

Point Reflection(const Line &L,const Point &P){
	Point projection=Projection(L,P);
	return projection+(projection-P);
}

int main(){
	L.read();
	scanf("%d",&Q);
	while (Q--){
		P.read();
		Point Ans=Reflection(L,P);
		printf("%.10Lf %.10Lf\n",Ans.X,Ans.Y);
	}
}


```