#include <cstdio>
#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>

using namespace std;
typedef double D;

struct P {
    D x, y;
    P(D x, D y) : x(x), y(y) { }
    P() { }
};


P operator +(P a, P b) {
    a.x += b.x, a.y += b.y;
    return a;
}

P operator -(P a, P b) {
    a.x -= b.x, a.y -= b.y;
    return a;
}

// ???????????????
P operator *(P p, D s) {
    p.x *= s, p.y *= s;
    return p;
}

D inp(P a, P b) {
    return a.x*b.x + a.y*b.y;
}

D norm(P p) {
    return inp(p, p);
}

struct L : vector<P> {
    L(P a, P b) {
        this->push_back(a);
        this->push_back(b);
    }

    L() {
        this->resize(2);
    }
};

// ??卒???l???????????????p?????????
// (l??????p??????????????????????????即????????????????賊???????)
// norm??則?????贈?????????(abs??則??????????????????)
P projection(L l, P p) {
    P a = l[1] - l[0];
    P b = p - l[0];
    double t = inp(b, a) / norm(a);
    return l[0] + a * t;
}

// ??卒???l???????????????p???????属?
// (l????????????????則属???p??????)
P reflection(L l, P p) {
    return p + (projection(l, p) - p) * 2;
}

int main() {
    double x, y;

    cin >> x >> y;
    P p0(x, y);

    cin >> x >> y;
    P p1(x, y);

    L l(p0, p1);

    int Q; cin >> Q;
    while(Q--) {
        cin >> x >> y;
        P p2(x, y);
        P p = reflection(l, p2);
        printf("%.10f %.10f\n", p.x, p.y);
    }
}
### Prompt

In CPP, your task is to solve 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 <cstdio>
#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>

using namespace std;
typedef double D;

struct P {
    D x, y;
    P(D x, D y) : x(x), y(y) { }
    P() { }
};


P operator +(P a, P b) {
    a.x += b.x, a.y += b.y;
    return a;
}

P operator -(P a, P b) {
    a.x -= b.x, a.y -= b.y;
    return a;
}

// ???????????????
P operator *(P p, D s) {
    p.x *= s, p.y *= s;
    return p;
}

D inp(P a, P b) {
    return a.x*b.x + a.y*b.y;
}

D norm(P p) {
    return inp(p, p);
}

struct L : vector<P> {
    L(P a, P b) {
        this->push_back(a);
        this->push_back(b);
    }

    L() {
        this->resize(2);
    }
};

// ??卒???l???????????????p?????????
// (l??????p??????????????????????????即????????????????賊???????)
// norm??則?????贈?????????(abs??則??????????????????)
P projection(L l, P p) {
    P a = l[1] - l[0];
    P b = p - l[0];
    double t = inp(b, a) / norm(a);
    return l[0] + a * t;
}

// ??卒???l???????????????p???????属?
// (l????????????????則属???p??????)
P reflection(L l, P p) {
    return p + (projection(l, p) - p) * 2;
}

int main() {
    double x, y;

    cin >> x >> y;
    P p0(x, y);

    cin >> x >> y;
    P p1(x, y);

    L l(p0, p1);

    int Q; cin >> Q;
    while(Q--) {
        cin >> x >> y;
        P p2(x, y);
        P p = reflection(l, p2);
        printf("%.10f %.10f\n", p.x, p.y);
    }
}
```