#include<iostream>
#include<vector>
#include<cmath>
#include<iomanip>
using namespace std;

struct Point{
    double x;
    double y;
};

int main()
{
    Point p1,p2;
    cin>>p1.x>>p1.y>>p2.x>>p2.y;
    int q;
    cin>>q;
    vector<Point> pp(q);
    for(int i=0; i<q; i++){
        cin>>pp[i].x>>pp[i].y;
    }
    double rc1,rc2,b1;
    rc1=(p1.y-p2.y)/(p1.x-p2.x);
    if(p1.x-p2.x==0){
        b1=p1.y;
        rc2=0;
    }else{
        b1=p1.y-rc1*p1.x;
        rc2=(-1)/rc1;
    }
    vector<double> bb(q);
    vector<Point> ans(q);
    for(int i=0; i<pp.size(); i++){
        if(rc1==0){
            ans[i].x=pp[i].x;
        }else{
            bb[i]=pp[i].y-rc2*pp[i].x;
            if(p1.x-p2.x==0){
                ans[i].x=0;
            }else if(rc2-rc1==0){
                ans[i].x=0;
            }else{
                ans[i].x=(b1-bb[i])/(rc2-rc1);
            }
        }
        if(p1.x-p2.x==0){
            ans[i].y=bb[i];
        }else{
            ans[i].y=rc1*ans[i].x+b1;
        }
        Point ans2[q];
        ans2[i].x=pp[i].x+2*(ans[i].x-pp[i].x);
        if(p1.y-p2.y==0){
            ans2[i].y=-pp[i].y;
        }else{
            ans2[i].y=rc2*ans2[i].x+bb[i];
        }
        cout<<fixed;
        cout<<setprecision(10)<<ans2[i].x<<" "<<ans2[i].y<<endl;;
    }
    return 0;
}

### Prompt

Construct a cpp code solution to the problem outlined:

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<vector>
#include<cmath>
#include<iomanip>
using namespace std;

struct Point{
    double x;
    double y;
};

int main()
{
    Point p1,p2;
    cin>>p1.x>>p1.y>>p2.x>>p2.y;
    int q;
    cin>>q;
    vector<Point> pp(q);
    for(int i=0; i<q; i++){
        cin>>pp[i].x>>pp[i].y;
    }
    double rc1,rc2,b1;
    rc1=(p1.y-p2.y)/(p1.x-p2.x);
    if(p1.x-p2.x==0){
        b1=p1.y;
        rc2=0;
    }else{
        b1=p1.y-rc1*p1.x;
        rc2=(-1)/rc1;
    }
    vector<double> bb(q);
    vector<Point> ans(q);
    for(int i=0; i<pp.size(); i++){
        if(rc1==0){
            ans[i].x=pp[i].x;
        }else{
            bb[i]=pp[i].y-rc2*pp[i].x;
            if(p1.x-p2.x==0){
                ans[i].x=0;
            }else if(rc2-rc1==0){
                ans[i].x=0;
            }else{
                ans[i].x=(b1-bb[i])/(rc2-rc1);
            }
        }
        if(p1.x-p2.x==0){
            ans[i].y=bb[i];
        }else{
            ans[i].y=rc1*ans[i].x+b1;
        }
        Point ans2[q];
        ans2[i].x=pp[i].x+2*(ans[i].x-pp[i].x);
        if(p1.y-p2.y==0){
            ans2[i].y=-pp[i].y;
        }else{
            ans2[i].y=rc2*ans2[i].x+bb[i];
        }
        cout<<fixed;
        cout<<setprecision(10)<<ans2[i].x<<" "<<ans2[i].y<<endl;;
    }
    return 0;
}

```