There is a square in the xy-plane. The coordinates of its four vertices are (x_1,y_1),(x_2,y_2),(x_3,y_3) and (x_4,y_4) in counter-clockwise order.
(Assume that the positive x-axis points right, and the positive y-axis points up.)
Takahashi remembers (x_1,y_1) and (x_2,y_2), but he has forgot (x_3,y_3) and (x_4,y_4).
Given x_1,x_2,y_1,y_2, restore x_3,y_3,x_4,y_4. It can be shown that x_3,y_3,x_4 and y_4 uniquely exist and have integer values.

-----Constraints-----
 - |x_1|,|y_1|,|x_2|,|y_2| \leq 100
 - (x_1,y_1) ≠ (x_2,y_2)
 - All values in input are integers.

-----Input-----
Input is given from Standard Input in the following format:
x_1 y_1 x_2 y_2

-----Output-----
Print x_3,y_3,x_4 and y_4 as integers, in this order.

-----Sample Input-----
0 0 0 1

-----Sample Output-----
-1 1 -1 0

(0,0),(0,1),(-1,1),(-1,0) is the four vertices of a square in counter-clockwise order.
Note that (x_3,y_3)=(1,1),(x_4,y_4)=(1,0) is not accepted, as the vertices are in clockwise order.

Difficulty: EASY

Solutions:
(x1, y1, x2, y2) = tuple(map(int, input().split()))
x3 = x2 - (y2 - y1)
y3 = y2 + (x2 - x1)
x4 = x3 - (y3 - y2)
y4 = y3 + (x3 - x2)
print(x3, y3, x4, y4)


(x1, y1, x2, y2) = map(int, input().split())
print(x2 - (y2 - y1), y2 + (x2 - x1), x1 - (y2 - y1), y1 + (x2 - x1), sep=' ')


(x1, y1, x2, y2) = map(int, input().split())
dx = x2 - x1
dy = y2 - y1
print(x1 + dx - dy, y1 + dx + dy, x1 - dy, y1 + dx)


(x1, y1, x2, y2) = map(int, input().split())
(x0, y0) = (x2 - x1, y2 - y1)
print(x2 - y0, y2 + x0, x1 - y0, y1 + x0)


(a, b, c, d) = map(int, input().split())
(e, f) = (c - (d - b), d + (c - a))
(g, h) = (a - (d - b), b + (c - a))
print(e, f, g, h)


(x_1, y_1, x_2, y_2) = map(int, input().split())
print(y_1 + x_2 - y_2, -x_1 + x_2 + y_2, x_1 + y_1 - y_2, -x_1 + y_1 + x_2)


(x1, y1, x2, y2) = map(int, input().split())
d1 = x2 - x1
d2 = y2 - y1
print(x2 - d2, y2 + d1, x1 - d2, y1 + d1)


(x1, y1, x2, y2) = map(int, input().split())
d = [x1 - x2, -(y1 - y2)]
print(x2 - d[1], y2 - d[0], x1 - d[1], y1 - d[0])


(x1, y1, x2, y2) = map(int, input().split())
x = x1 - x2
y = y1 - y2
print(x2 + y, y2 - x, x1 + y, y1 - x)


(a, b, c, d) = map(int, input().split())
print(c + b - d, -a + c + d, a + b - d, -a + c + b)


import math
(x1, y1, x2, y2) = map(int, input().split())
s = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
a = math.atan2(y2 - y1, x2 - x1)
x3 = x2 - math.sin(a) * s
y3 = y2 + math.cos(a) * s
x4 = x1 - math.sin(a) * s
y4 = y1 + math.cos(a) * s
print(round(x3), round(y3), round(x4), round(y4))


(a, b, c, d) = list(map(int, input().split()))
e = c + (b - d)
f = d + (c - a)
print(e, f, e + (d - f), f + (e - c))


(x1, y1, x2, y2) = [int(s) for s in input().split()]
(dx, dy) = (x2 - x1, y2 - y1)
print(x2 - dy, y2 + dx, x1 - dy, y1 + dx)


(x1, y1, x2, y2) = map(int, input().split())
dx = x2 - x1
dy = y2 - y1
x3 = x2 - dy
y3 = y2 + dx
x4 = x3 - dx
y4 = y3 - dy
print(*[x3, y3, x4, y4])


(x1, y1, x2, y2) = map(int, input().split())
print(x2 - (y2 - y1), y2 - (x1 - x2), x1 - (y2 - y1), y1 - (x1 - x2), end='')


(A, B, C, D) = map(int, input().split())
dx = C - A
dy = D - B
print(C - dy, D + dx, C - dy - dx, D + dx - dy)


(x1, y1, x2, y2) = map(int, input().split())
w = x2 - x1
h = y2 - y1
print(x2 - h, y2 + w, x1 - h, y1 + w)


(x1, y1, x2, y2) = [int(x) for x in input().split()]
print(x2 + y1 - y2, y2 + x2 - x1, x1 + y1 - y2, y1 + x2 - x1)


(x1, y1, x2, y2) = map(int, input().split())
X = x2 - x1
Y = y2 - y1
print(x2 - Y, y2 + X, x1 - Y, y1 + X)


(a, b, c, d) = (int(i) for i in input().strip().split(' '))
x = c - a
y = d - b
print(c - y, d + x, a - y, b + x)


(a, b, c, d) = map(int, input().split())
ve1 = c - a
ve2 = d - b
print(c - ve2, d + ve1, a - ve2, b + ve1)


(x1, y1, x2, y2) = map(int, input().split())
a = x2 - x1
b = y2 - y1
x3 = x2 - b
y3 = y2 + a
x4 = x3 - a
y4 = y3 - b
print(x3, y3, x4, y4)


(x1, y1, x2, y2) = map(int, input().split())
(a, s) = (x2 - x1, y2 - y1)
print(-s + x2, y2 + a, x1 - s, y1 + a)


(x1, y1, x2, y2) = list(map(int, input().split()))
print(x2 - y2 + y1, y2 + x2 - x1, x1 - y2 + y1, y1 + x2 - x1)


(x1, y1, x2, y2) = map(int, input().split())
h = [x2 - x1, y2 - y1]
print(x2 - h[1], y2 + h[0], x1 - h[1], y1 + h[0])


(x1, y1, x2, y2) = map(int, input().split())
x12 = x2 - x1
y12 = y2 - y1
print(x2 - y12, y2 + x12, x1 - y12, y1 + x12)


import math
(a, b, c, d) = [int(x) for x in input().split()]
x = c - a
y = d - b
print(c - y, d + x, a - y, b + x)


(x1, y1, x2, y2) = map(int, input().split())
ax = x2 - x1
ay = y2 - y1
x3 = x2 - ay
y3 = y2 + ax
x4 = x1 - ay
y4 = y1 + ax
print(x3, y3, x4, y4)


(x_1, y_1, x_2, y_2) = map(int, input().split())
s = x_2 - x_1
t = y_1 - y_2
print(x_2 + t, y_2 + s, x_1 + t, y_1 + s)


(x1, y1, x2, y2) = map(int, input().split())
x = x2 - x1
y = y2 - y1
x3 = x2 - y
y3 = y2 + x
x4 = x1 - y
y4 = y1 + x
print(x3, y3, x4, y4)


(x1, y1, x2, y2) = map(int, input().split())
k1 = x2 - x1
k2 = y2 - y1
print(x2 - k2, y2 + k1, x2 - k2 - k1, y2 + k1 - k2)


x = [0] * 4
y = [0] * 4
(x[0], y[0], x[1], y[1]) = map(int, input().split())
xdist = x[1] - x[0]
ydist = y[1] - y[0]
x[2] = x[1] - ydist
y[2] = y[1] + xdist
x[3] = x[2] - xdist
y[3] = y[2] - ydist
print(x[2], y[2], x[3], y[3])


(p, q, r, s) = map(int, input().split())
print(r - (s - q), s + (r - p), r - (s - q) - (r - p), s + (r - p) - (s - q))


import sys
(x1, y1, x2, y2) = map(int, input().split())
print(x2 - (y2 - y1), y2 + (x2 - x1), x1 - (y2 - y1), y1 + (x2 - x1))


(x1, y1, x2, y2) = map(int, input().split())
(x3_1, x3_2) = (x2 - abs(y2 - y1), x2 + abs(y2 - y1))
(x4_1, x4_2) = (x1 - abs(y2 - y1), x1 + abs(y2 - y1))
(y3_1, y3_2) = (y2 - abs(x2 - x1), y2 + abs(x2 - x1))
(y4_1, y4_2) = (y1 - abs(x2 - x1), y1 + abs(x2 - x1))
if x2 > x1 and y2 > y1:
	print(x3_1, y3_2, x4_1, y4_2)
elif x2 > x1 and y2 <= y1:
	print(x3_2, y3_2, x4_2, y4_2)
elif x2 <= x1 and y2 > y1:
	print(x3_1, y3_1, x4_1, y4_1)
elif x2 <= x1 and y2 <= y1:
	print(x3_2, y3_1, x4_2, y4_1)


(a, b, c, d) = (int(i) for i in input().split())
print(b + c - d, c + d - a, a + b - d, b + c - a)


(x1, y1, x2, y2) = map(int, input().split())
m = x2 - x1
n = y2 - y1
print(x2 - n, y2 + m, x1 - n, y1 + m)


(x1, y1, x2, y2) = map(int, input().split())
(j, k) = (x2 - x1, y2 - y1)
print(x2 - k, y2 + j, x1 - k, y1 + j)


(x1, y1, x2, y2) = map(int, input().split())
X = x1 - x2
Y = y1 - y2
(x3, y3) = (x2 + Y, y2 - X)
(x4, y4) = (x3 + X, y3 + Y)
print(x3, y3, x4, y4)


A = [int(x) for x in input().split()]
a = A[2] - A[0]
b = A[3] - A[1]
print(A[2] - b, A[3] + a, A[0] - b, A[1] + a)


(a, b, c, d) = map(int, input().split())
s = c - a
t = d - b
x_3 = c - t
y_3 = d + s
x_4 = x_3 - s
y_4 = y_3 - t
print(str(x_3) + ' ' + str(y_3) + ' ' + str(x_4) + ' ' + str(y_4))


(a, b, c, d) = list(map(int, input().split()))
H = c - a
W = d - b
e = c - W
f = d + H
g = a - W
h = b + H
print(e, f, g, h, end='')


a = list(map(int, input().split()))
x = a[2] - a[0]
y = a[3] - a[1]
print(a[2] - y, a[3] + x, a[2] - y - x, a[3] + x - y, end=' ')


(x, y, s, t) = map(int, input().split())
(a, b) = (y - t, s - x)
print(s + a, t + b, x + a, y + b)


(x1, y1, x2, y2) = map(int, input().split())
vx = x2 - x1
vy = y2 - y1
print(x2 - vy, y2 + vx, x2 - vy - vx, y2 + vx - vy)


(x1, y1, x2, y2) = map(int, input().split())
a = x2 - x1
b = y2 - y1
print(' '.join(map(str, [x2 - b, y2 + a, x1 - b, y1 + a])))


(x1, y1, x2, y2) = map(int, input().split())
print(f'{x2 - (y2 - y1)} {y2 + (x2 - x1)} {x1 - (y2 - y1)} {y1 + (x2 - x1)}')


a = [int(x) for x in input().split()]
print(*[sum(a) - 2 * a[3 * (not i % 2)] - a[i] for i in [0, 1, 2, 3]])


(a, b, x, y) = map(int, input().split())
m = b - y
n = x - a
print(x + m, y + n, a + m, b + n)


(x1, y1, x2, y2) = map(int, input().split())
a = x1 - x2
b = y1 - y2
print(x2 + b, y2 - a, x1 + b, y1 - a)


(x1, y1, x2, y2) = map(int, input().split())
if y2 >= y1 and x2 >= x1:
	y3 = y2 + abs(x2 - x1)
	x3 = x2 - abs(y2 - y1)
elif y2 >= y1 and x1 > x2:
	x3 = x2 - abs(y2 - y1)
	y3 = y2 - abs(x2 - x1)
elif y1 > y2 and x2 >= x1:
	x3 = x2 + abs(y2 - y1)
	y3 = y2 + abs(x2 - x1)
elif y1 > y2 and x1 > x2:
	x3 = x2 + abs(y2 - y1)
	y3 = y2 - abs(x2 - x1)
x4 = x1 + x3 - x2
y4 = y1 + y3 - y2
print(x3, y3, x4, y4)


(x1, y1, x2, y2) = map(int, input().split())
print('{} {} {} {}'.format(y1 - y2 + x2, x2 - x1 + y2, y1 - y2 + x1, x2 - x1 + y1))


(x, y, z, w) = list(map(int, input().split(' ')))
print('{0} {1} {2} {3}'.format(z - (w - y), w + z - x, x - (w - y), y + z - x))


(a, b, c, d) = map(int, input().split())
(dx, dy) = (a - c, d - b)
print(c - dy, d - dx, a - dy, b - dx)


(x1, y1, x2, y2) = map(int, input().split())
v = (-y2 + y1, x2 - x1)
print(x2 - y2 + y1, y2 + x2 - x1, x1 - y2 + y1, y1 + x2 - x1)


import sys
input = sys.stdin.readline

def main():
	(x1, y1, x2, y2) = map(int, input().split())
	x12 = x2 - x1
	y12 = y2 - y1
	x3 = x12 - y12 + x1
	y3 = x12 + y12 + y1
	x4 = -y12 + x1
	y4 = x12 + y1
	print('{} {} {} {}'.format(x3, y3, x4, y4))

def __starting_point():
	main()
__starting_point()


(x1, y1, x2, y2) = map(int, input().split())
p = x2 - x1
q = y2 - y1
print(x2 - q, y2 + p, x1 - q, y1 + p)


(X, Y, Z, W) = map(int, input().split())
a = Z - X
b = W - Y
print(Z - b, W + a, X - b, Y + a)


(x1, y1, x2, y2) = map(int, input().split())
v = (-(y2 - y1), x2 - x1)
print(x2 + v[0], y2 + v[1], x1 + v[0], y1 + v[1])


t = list(map(int, input().split()))
print(t[2] + t[1] - t[3], -t[0] + t[2] + t[3], t[0] + t[1] - t[3], -t[0] + t[2] + t[1])


(x1, y1, x2, y2) = map(int, input().split())
diff_x = x2 - x1
diff_y = y2 - y1
print(x2 - diff_y, y2 + diff_x, x1 - diff_y, y1 + diff_x)


import math
(x1, y1, x2, y2) = map(int, input().split())
a = x2 - x1
b = y2 - y1
print(x2 - b, y2 + a, x1 - b, y1 + a)


(x1, y1, x2, y2) = map(int, input().split())
xy = x2 - x1
yx = y1 - y2
print(x2 + yx, y2 + xy, x1 + yx, y1 + xy)


(x1, y1, x2, y2) = map(int, input().split())
k = y2 - y1
m = x2 - x1
print(x2 - k, y2 + m, x1 - k, y1 + m)


(x1, y1, x2, y2) = map(int, input().split())
b = [-(y2 - y1), x2 - x1]
print(x2 + b[0], y2 + b[1], x1 + b[0], y1 + b[1])


(x, y, xx, yy) = map(int, open(0).read().split())
print(xx - (yy - y), yy + (xx - x), x - (yy - y), y + (xx - x))


(a, b, c, d) = map(int, input().split())
x3 = c - (d - b)
y3 = d + (c - a)
x4 = a - (d - b)
y4 = b + (c - a)
print(x3, y3, x4, y4)


(A, B, C, D) = map(int, input().split())
print(C - D + B, D + C - A, A - D + B, B + C - A)


(a, b, c, d) = map(int, input().split())
(x, y) = (c - a, d - b)
(h, i, j, k) = (c - y, d + x, a - y, b + x)
print(h, i, j, k)


(a, b, c, d) = map(int, input().split())
x = c - a
y = d - b
ans1 = a + x - y
ans2 = b + x + y
ans3 = a - y
ans4 = b + x
print(ans1, ans2, ans3, ans4)


import sys
import math
sys.setrecursionlimit(10 ** 8)
ini = lambda : int(sys.stdin.readline())
inm = lambda : map(int, sys.stdin.readline().split())
inl = lambda : list(inm())
ins = lambda : sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print('\x1b[33m', *a, '\x1b[0m', **dict(file=sys.stderr, **kw))
(x1, y1, x2, y2) = inm()
y3 = y2 + (x2 - x1)
x3 = x2 - (y2 - y1)
y4 = y3 - (y2 - y1)
x4 = x3 - (x2 - x1)
print(x3, y3, x4, y4)


(x1, y1, x2, y2) = map(int, input().split())
(i, j) = (x2 - x1, y2 - y1)
print(x2 - j, y2 + i, x1 - j, y1 + i)


import math
(x1, y1, x2, y2) = [int(x) for x in input().split()]
x12 = x2 - x1
y12 = y2 - y1
L = math.sqrt(x12 ** 2 + y12 ** 2)
x3 = x12 - y12 + x1
y3 = x12 + y12 + y1
x4 = -y12 + x1
y4 = x12 + y1
print('{} {} {} {}'.format(x3, y3, x4, y4))


(x1, y1, x2, y2) = (int(i) for i in input().split())
x3 = x2 + (y1 - y2)
y3 = y2 + (x2 - x1)
x4 = x3 + (y2 - y3)
y4 = y3 + (x3 - x2)
print(x3, y3, x4, y4)


(x, y, X, Y) = map(int, input().split())
print(X - Y + y, Y + X - x, x - Y + y, y + X - x)


(x1, y1, x2, y2) = list(map(int, input().split()))
xdiff = x2 - x1
ydiff = y2 - y1
x3 = x2 - ydiff
y3 = y2 + xdiff
x4 = x3 - xdiff
y4 = y3 - ydiff
print(str(x3) + ' ' + str(y3) + ' ' + str(x4) + ' ' + str(y4))


(x1, y1, x2, y2) = list(map(int, input().strip().split()))
dx = x2 - x1
dy = y2 - y1
print(x2 - dy, y2 + dx, x1 - dy, y1 + dx)


(x, y, s, t) = map(int, input().split())
a = s + y - t
b = s + t - x
c = x + y - t
d = s + y - x
print(a, b, c, d)


(a, b, c, d) = map(int, input().split())
x = a - (d - b)
y = b + (c - a)
z = x + (c - a)
w = y + (d - b)
print(z, w, x, y)


import sys
read = sys.stdin.read
readlines = sys.stdin.readlines

def main():
	(x1, y1, x2, y2) = map(int, input().split())
	diff_x = x2 - x1
	diff_y = y2 - y1
	r = [x2 - diff_y, y2 + diff_x, x1 - diff_y, y1 + diff_x]
	print(*r, sep=' ')

def __starting_point():
	main()
__starting_point()


(x1, y1, x2, y2) = map(int, input().split())
(xd, yd) = (x2 - x1, y2 - y1)
print(x2 - yd, y2 + xd, x1 - yd, y1 + xd)


(x1, y1, x2, y2) = map(int, input().split())
sx = x2 - x1
sy = y2 - y1
print(x2 - sy, y2 + sx, x1 - sy, y1 + sx)


(x1, y1, x2, y2) = map(int, input().split())
h = y2 - y1
w = x2 - x1
x3 = x2 - h
y3 = y2 + w
x4 = x3 - w
y4 = y3 - h
print(x3, y3, x4, y4)


(x, y, a, b) = map(int, input().split())
(dx, dy) = (a - x, b - y)
(c, d) = (a - dy, b + dx)
(e, f) = (c - dx, d - dy)
print(c, d, e, f)


n = list(map(int, input().split()))
print(n[2] + n[1] - n[3], n[3] - n[0] + n[2], n[0] + n[1] - n[3], n[1] - n[0] + n[2])


(x1, y1, x2, y2) = list(map(int, input().split()))
vector = (x2 - x1, y2 - y1)
(x3, y3) = (x2 - vector[1], y2 + vector[0])
(x4, y4) = (x1 - vector[1], y1 + vector[0])
print(x3, y3, x4, y4)


(a, b, c, d) = [int(s) for s in input().split()]
x = c - a
y = d - b
A = c - y
B = d + x
C = A - x
D = B - y
print(*[A, B, C, D])


(x1, y1, x2, y2) = tuple(map(int, input().split()))
print(x2 + y1 - y2, y2 - x1 + x2, x1 + y1 - y2, y1 - x1 + x2)


(x, y, xx, yy) = list(map(int, input().split()))
print(xx - (yy - y), yy + (xx - x), x - (yy - y), y + (xx - x))


(x, y, z, w) = map(int, input().split())
a = z - x
b = w - y
print(z - b, w + a, x - b, y + a)


(u, v, x, y) = map(int, input().split())
[p, q] = [x - (y - v), y + (x - u)]
[r, s] = [p - (q - y), q + (p - x)]
print(p, q, r, s)


(X1, Y1, X2, Y2) = map(int, input().split())
a = X2 - X1
b = Y2 - Y1
X3 = X2 - b
Y3 = Y2 + a
X4 = X1 - b
Y4 = Y1 + a
print(X3, end=' ')
print(Y3, end=' ')
print(X4, end=' ')
print(Y4)


(x, y, u, v) = map(int, input().split())
(a, b) = (u - x, v - y)
print(u - b, v + a, u - b - a, v + a - b)


(x1, y1, x2, y2) = map(int, input().split())
x_len = x2 - x1
y_len = y2 - y1
print('{} {} {} {}'.format(x2 - y_len, y2 + x_len, x1 - y_len, y1 + x_len))