#include <iostream>
#include <math.h>
#include <stdio.h>
#include <vector>

using namespace std;

// 2次元ベクトルクラス
class Vector {
public:
    double x, y;
    
    Vector() {
        x = 0.0;
        y = 0.0;
    }
    
    Vector(double nx, double ny) {
        x = nx;
        y = ny;
    }
    
    void set(double nx, double ny) {
        x = nx;
        y = ny;
    }
    
    void setX(double nx) {
        x = nx;
    }
    
    void setY(double ny) {
        y = ny;
    }
    
    // 回転させる
    // rはラジアン
    void rotate(double r) {
        x = x * cos(r) - y * sin(r);
        x = x * sin(r) + y * cos(r);
    }
    
    // ベクトルの大きさを求める
    double norm() const {
        return sqrt(x * x + y * y);
    }
    
    // 内積を求める
    double dot(const Vector& vec) const {
        return x * vec.x + y * vec.y;
    }
    
    // 余弦を求める
    double getCos(const Vector& vec) const {
        double nor = norm() * vec.norm();
        if (nor == 0.0) {
            return 0.0;
        } else {
            return dot(vec) / nor;
        }
    }
    
    // 単位ベクトルを返す
    Vector getUnit() const {
        Vector v;
        double mag = norm();
        if (mag == 0.0) {
            v.set(0.0, 0.0);
        } else {
            v.set(x / mag, y / mag);
        }
        return v;
    }
    
    void operator = (const Vector& vec) {
        x = vec.x;
        y = vec.y;
    }
    
    Vector operator + (const Vector& vec) {
        Vector v(x + vec.x, y + vec.y);
        return v;
    }
    
    Vector operator - (const Vector& vec) {
        Vector v(x - vec.x, y - vec.y);
        return v;
    }
    
    Vector operator * (const Vector& vec) {
        Vector v(x * vec.x, y * vec.y);
        return v;
    }
    
    Vector operator * (double f) {
        Vector v(x * f, y * f);
        return v;
    }
    
    Vector operator / (const Vector& vec) {
        Vector v;
        if (vec.x == 0.0) {
            v.setX(0.0);
        } else {
            v.setX(x / vec.x);
        }
        
        if (vec.y == 0.0) {
            v.setY(0.0);
        } else {
            v.setY(y / vec.y);
        }
        return v;
    }
    
    Vector operator / (double f) {
        Vector v;
        if (f == 0.0) {
            v.set(0.0, 0.0);
        } else {
            v.set(x / f, y / f);
        }
        return v;
    }
    
    void operator += (const Vector& vec) {
        x += vec.x;
        y += vec.y;
    }
    
    void operator -= (const Vector& vec) {
        x -= vec.x;
        y -= vec.y;
    }
    
    void operator *= (const Vector& vec) {
        x *= vec.x;
        y *= vec.y;
    }
    
    void operator /= (const Vector& vec) {
        if (vec.x == 0.0) {
            x = 0.0;
        } else {
            x /= vec.x;
        }
        
        if (vec.y == 0.0) {
            y = 0.0;
        } else {
            y /= vec.y;
        }
    }
};

// ベクトル1をベクトル2に正射影したベクトルを求める
static Vector getProjection(const Vector& vec1, const Vector& vec2) {
    Vector vec(vec2.getUnit() * vec1.norm() * vec1.getCos(vec2));
    return vec;
}


int main() {
    double a,b,c,d;
    cin >> a >> b >> c >> d;
    Vector vec1(a, b);
    Vector vec2(c, d);
    Vector vec(vec2 - vec1);
    
    int n;
    cin >> n;
    
    vector<Vector> results;
    for (int i = 0; i < n; i++) {
        double x, y;
        cin >> x >> y;
        Vector p(x - vec1.x, y - vec1.y);
        Vector pro = getProjection(p, vec) + vec1; // 正射影ベクトル
        
        Vector ret(getProjection(p, vec) - p);
        ret += pro;
        
        results.push_back(ret);
    }
    
    for (int i = 0; i < results.size(); i++) {
        printf("%.10f %.10f\n", results[i].x, results[i].y);
    }
    return 0;
}


Measured memory_bytes: 3228