Problem:
Reflection

For given three points p1, p2, p, find the reflection point x of p onto p1p2.

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.

Constraints

1 ≤ q ≤ 1000

-10000 ≤ xi, yi ≤ 10000

p1 and p2 are not identical.

Sample Input 1

0 0 2 0
3
-1 1
0 1
1 1

Sample Output 1

-1.0000000000 -1.0000000000
0.0000000000 -1.0000000000
1.0000000000 -1.0000000000

Sample Input 2

0 0 3 4
3
2 5
1 4
0 3

Sample Output 2

4.2400000000 3.3200000000
3.5600000000 2.0800000000
2.8800000000 0.8400000000

Solution in Ruby (judge verdict: Accepted)

class Point
  attr_accessor :x, :y
  def initialize(x, y)
    @x = x
    @y = y
  end

  def +(p)
    Point.new(@x + p.x, @y + p.y)
  end

  def -(p)
    Point.new(@x - p.x, @y - p.y)
  end

  def *(k)
    Point.new(@x * k, @y * k)
  end

  def to_s
    "#{@x} #{@y}"
  end
end

def dot(a, b)
  a.x * b.x + a.y * b.y
end

def cross(a, b)
  a.x * b.y - a.y * b.x
end

def norm(a)
  a.x * a.x + a.y * a.y
end

Segment = Struct.new('Segment', :p1, :p2)

def project(s, p)
  base = s.p2 - s.p1
  r = dot(p - s.p1, base).to_f / norm(base)
  s.p1 + base * r
end

def reflect(s, p)
  p + (project(s, p) -p) * 2.0
end

x0, y0, x1, y1 = gets.split.map(&:to_i)
p0 = Point.new(x0, y0)
p1 = Point.new(x1, y1)
base = Segment.new(p0, p1)

n = gets.to_i
n.times do
  x, y = gets.split.map(&:to_i)
  p = Point.new(x, y)
  puts reflect(base, p).to_s
end