Language: C++

#ifndef ___Class_Point
#define ___Class_Point

class Point
{
private:

	double x_;
	double y_;

public:

	Point() : x_(0), y_(0) { }

	explicit Point(double x, double y) : x_(x), y_(y) { }

	explicit Point(double x1, double y1, double x2, double y2) : x_(x2 - x1), y_(y2 - y1) { }

	double x() const { return x_; }
	double y() const { return y_; }

	Point& operator+= (const Point& p) { x_ += p.x_; y_ += p.y_; return *this; }
	Point& operator-= (const Point& p) { x_ -= p.x_; y_ -= p.y_; return *this; }

	Point& operator*= (double s) { x_ *= s; y_ *= s; return *this; }
	Point& operator/= (double s) { x_ /= s; y_ /= s; return *this; }

	friend bool operator== (const Point& p1, const Point& p2) { return p1.x_ == p2.x_ && p1.y_ == p2.y_; }
	friend bool operator!= (const Point& p1, const Point& p2) { return !(p1 == p2); }

	friend Point operator+ (const Point& p1, const Point& p2) { return Point(p1.x_ + p2.x_, p1.y_ + p2.y_); }
	friend Point operator- (const Point& p1, const Point& p2) { return Point(p1.x_ - p2.x_, p1.y_ + p2.y_); }

	friend Point operator* (const Point& p, double s) { return Point(p.x_ * s, p.y_ * s); }
	friend Point operator/ (const Point& p, double s) { return Point(p.x_ / s, p.y_ / s); }

	friend Point operator* (double s, const Point& p) { return Point(p.x_ * s, p.y_ * s); }
};

#endif

#ifndef ___Class_Vector
#define ___Class_Vector

#include <cmath>

typedef Point Vector;

double norm(Vector p1)
{
	return p1.x() * p1.x() + p1.y() * p1.y();
}

double abs(Vector p1)
{
	return sqrt(norm(p1));
}

double angle(Vector p1)
{
	return atan2(p1.y(), p1.x());
}

double angle(Vector p1, Vector p2)
{
	return angle(p2) - angle(p1);
}

double cross(Vector p1, Vector p2)
{
	return p1.x() * p2.y() - p1.y() * p2.x();
}

double dot(Vector p1, Vector p2)
{
	return p1.x() * p2.x() + p1.y() * p2.y();
}

#endif

#ifndef ___Computational_Geometry
#define ___Computational_Geometry

bool palarell(Vector p1, Vector p2)
{
	return cross(p1, p2) == 0;
}

bool palarell(Point p1_s, Point p1_e, Point p2_s, Point p2_e)
{
	return palarell(p1_e - p1_s, p2_e - p2_s);
}

bool orthogonal(Vector p1, Vector p2)
{
	return dot(p1, p2) == 0;
}

bool orthogonal(Point p1_s, Point p1_e, Point p2_s, Point p2_e)
{
	return orthogonal(p1_e - p1_s, p2_e - p2_s);
}

double dist_sqr(Point p1, Point p2)
{
	return pow(p2.x() - p1.x(), 2) + pow(p2.y() - p1.y(), 2);
}

double distance(Point p1, Point p2)
{
	return sqrt(dist_sqr(p1, p2));
}

Vector projection(Vector hypo, Vector base)
{
	return base * (dot(hypo, base) / norm(base));
}

Vector reflection(Vector hypo, Vector base)
{
	return base + (projection(hypo, base) - hypo) * 2.0;
}

#endif

#include <cstdio>

#pragma warning(disable: 4996)

int x1, y1, x2, y2, x3, y3, q;

int main()
{
	scanf("%d", &x1);
	scanf("%d", &y1);
	scanf("%d", &x2);
	scanf("%d", &y2);

	Vector p(x1, y1, x2, y2);

	scanf("%d", &q);

	for (int i = 0; i < q; i++)
	{
		scanf("%d", &x3);
		scanf("%d", &y3);

		Vector q(x1, y1, x3, y3);

		Vector r = reflection(q, p);

		printf("%d %d\n", r.x(), r.y());
	}

	return 0;
}

Compiler output:
a.cc:130:9: error: 'int y1' redeclared as different kind of entity
  130 | int x1, y1, x2, y2, x3, y3, q;
      |         ^~
In file included from /usr/include/features.h:523,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h:39,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h:683,
                 from /usr/include/c++/14/bits/requires_hosted.h:31,
                 from /usr/include/c++/14/cmath:41,
                 from a.cc:45:
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:257:1: note: previous declaration 'double y1(double)'
  257 | __MATHCALL (y1,, (_Mdouble_));
      | ^~~~~~~~~~
a.cc: In function 'int main()':
a.cc:139:32: error: no matching function for call to 'Point::Point(int&, double (&)(double) noexcept, int&, int&)'
  139 |         Vector p(x1, y1, x2, y2);
      |                                ^
a.cc:17:18: note: candidate: 'Point::Point(double, double, double, double)'
   17 |         explicit Point(double x1, double y1, double x2, double y2) : x_(x2 - x1), y_(y2 - y1) { }
      |                  ^~~~~
a.cc:17:42: note:   no known conversion for argument 2 from 'double(double) noexcept' to 'double'
   17 |         explicit Point(double x1, double y1, double x2, double y2) : x_(x2 - x1), y_(y2 - y1) { }
      |                                   ~~~~~~~^~
a.cc:15:18: note: candidate: 'Point::Point(double, double)'
   15 |         explicit Point(double x, double y) : x_(x), y_(y) { }
      |                  ^~~~~
a.cc:15:18: note:   candidate expects 2 arguments, 4 provided
a.cc:13:9: note: candidate: 'Point::Point()'
   13 |         Point() : x_(0), y_(0) { }
      |         ^~~~~
a.cc:13:9: note:   candidate expects 0 arguments, 4 provided
a.cc:4:7: note: candidate: 'constexpr Point::Point(const Point&)'
    4 | class Point
      |       ^~~~~
a.cc:4:7: note:   candidate expects 1 argument, 4 provided
a.cc:4:7: note: candidate: 'constexpr Point::Point(Point&&)'
a.cc:4:7: note:   candidate expects 1 argument, 4 provided
a.cc:148:40: error: no matching function for call to 'Point::Point(int&, double (&)(double) noexcept, int&, int&)'
  148 |                 Vector q(x1, y1, x3, y3);
      |                                        ^
a.cc:17:18: note: candidate: 'Point::Point(double, double, double, double)'
   17 |         explicit Point(double x1, double y1, double x2, double y2) : x_(x2 - x1), y_(y2 - y1) { }
      |                  ^~~~~
a.cc:17:42: note:   no known conversion for argument 2 from 'double(double) noexcept' to 'double'
   17 |         explicit Point(double x1, double y1, double x2, double y2) : x_(x2 - x1), y_(y2 - y1) { }
      |                                   ~~~~~~~^~
a.cc:15:18: note: candidate: 'Point::Point(double, double)'
   15 |         explicit Point(double x, double y) : x_(x), y_(y) { }
      |                  ^~~~~
a.cc:15:18: note:   candidate expects 2 arguments, 4 provided
a.cc:13:9: note: candidate: 'Point::Point()'
   13 |         Point() : x_(0), y_(0) { }
      |         ^~~~~
a.cc:13:9: note:   candidate expects 0 arguments, 4 provided
a.cc:4:7: note: candidate: 'constexpr Point::Point(const Point&)'
    4 | class Point
      |       ^~~~~
a.cc:4:7: note:   candidate expects 1 argument, 4 provided
a.cc:4:7: note: candidate: 'constexpr Point::Point(Point&&)'
a.cc:4:7: note:   candidate expects 1 argument, 4 provided