Problem:
 Score : 200 points    Problem Statement 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 1 0 0 0 1      Sample Output 1 -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.       Sample Input 2 2 3 6 6      Sample Output 2 3 10 -1 7       Sample Input 3 31 -41 -59 26      Sample Output 3 -126 -64 -36 -131

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

diff_x = x2 - x1
diff_y = y2 - y1

x3 = x2 + (-diff_y)
y3 = y2 + diff_x
tmp = diff_x
diff_x = -diff_y
diff_y = tmp

x4 = x3 + (-diff_y)
y4 = y3 + diff_x


print(x3,y3,x4,y4)

Solution (Python):
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])

Solution (Python):
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)

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

Solution (Python):
x1,y1,x2,y2=map(int,input().split())
dx=x2-x1
dy=y2-y1

x3,y3,x4,y4=0,0,0,0

x3=x2-dy
y3=y2+dx

x4=x1-dy
y4=y1+dx

print(x3,y3,x4,y4)

Solution (Python):
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)

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

Solution (Python):

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

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

print(x2 + y1 - y2, y2 - x1 + x2, y1 - y2 + x1, y1 - x1 + x2)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

add_1 = x2-x1
add_2 = y2-y1

x3, y3 = x2-add_2, y2+add_1
x4, y4 = x3-add_1, y3-add_2

print(x3, y3, x4, y4)

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

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

Solution (Python):
import sys, math
def input():
    return sys.stdin.readline()[:-1]
from itertools import permutations, combinations
from collections import defaultdict, Counter
from math import factorial
from bisect import bisect_left 


sys.setrecursionlimit(10**7)
x1, y1, x2, y2 = map(int, input().split())

v1 = x2 - x1, y2 - y1
v2 = -v1[1], v1[0]
v3 = -v2[1], v2[0]

x3, y3 = x2 + v2[0], y2 + v2[1]
x4, y4 = x3 + v3[0], y3 + v3[1]

print(x3, y3, x4, y4)

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

Solution (Python):
x1,y1,x2,y2 = map(int, input().split())

x3 = x2 - (y2 - y1)
x4 = x3 - (x2 - x1)
y3 = y2 + (x2 - x1)
y4 = y3 - (y2 - y1)

print(x3, y3, x4, y4)

Solution (Python):
import numpy as np
 
x1,y1,x2,y2 = map(int,input().split())
 
x1y1 = np.array([x1,y1])
x2y2 = np.array([x2,y2])
 
vector = x1y1 - x2y2
rotation = np.array([[0,1],
                     [-1,0]])
rotated_vector = np.dot(rotation,vector)
x3y3 = x2y2 + rotated_vector
x4y4 = x3y3 + vector
 
print(*x3y3,end=" ")
print(*x4y4)

Solution (Python):
import numpy as np
 
x1,y1,x2,y2 = map(int,input().split())
 
x1y1 = np.array([x1,y1])
x2y2 = np.array([x2,y2])
 
vector = x1y1 - x2y2
rotation = np.array([[0,1],
                     [-1,0]])
rotated_vector = np.dot(rotation,vector)
x3y3 = x2y2 + rotated_vector
x4y4 = x3y3 + vector
 
print(x3y3[0],x3y3[1],x4y4[0],x4y4[1])

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

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

x = x1 - x2
y = y1 - y2
x3 = x2 + y
y3 = y2 - x
x4 = x1 + y
y4 = y1 - x
print(x3, y3, x4, y4)

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

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

Solution (Python):
x1, y1, x2, y2 = map(int,input().split())
A = x2 - x1
B = y2 - y1

print(x2 - B, y2 + A, x1 - B, y1 + A)

Solution (Python):
from functools import reduce
import math

def main():
    
    
    
    

    
    
    
    
    
    

    
    

    
    
    
    
    
    
    
    
    
    INF = float("inf")

    
    MOD = 10**9+7
    
    
    
    
    
    
    
    
    x1, y1, x2, y2 = (int(_) for _ in input().split())  
    
    
    
    
    
    

    
    
    
    
    dx = x2-x1
    dy = y2-y1
    
    tmp=dx
    dx = -dy
    dy = tmp
    x_3 = x2 +dx
    y_3 = y2 +dy

    tmp=dx
    dx = -dy
    dy = tmp
    x_4 = x_3 +dx
    y_4 = y_3 +dy
    print(x_3,y_3,x_4,y_4)
    
if __name__ == '__main__':
    main()

Solution (Python):
x1,y1,x2,y2=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)

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

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

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

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

dx = abs(x1 - x2)
dy = abs(y1 - y2)

if y1 < y2:
  x3 = x2 - dy
  x4 = x1 - dy
else:
  x3 = x2 + dy
  x4 = x1 + dy
if x1 < x2:
  y3 = y2 + dx
  y4 = y1 + dx
else:
  y3 = y2 - dx
  y4 = y1 - dx
  
print(x3, y3, x4, y4)

Solution (Python):
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,y3,x4,y4)

Solution (Python):




def main():
    X1, Y1, X2, Y2 = map(int, input().split())

    x, y = X2 - X1, Y2 - Y1
    print(X2 - y, Y2 + x, X1 - y, Y1 + x)


if __name__ == "__main__":
    main()

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

Solution (Python):
a, b, c, d = map(int, input().split())
x = c - a
y = d - b
print(c-y, d+x, a-y, b+x)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
v1 = [x2-x1, y2-y1]
v2 = [-v1[1], v1[0]]
x3 = x2+v2[0]
y3  = y2+v2[1]
x4 = x3+x1-x2
y4 = y3+y1-y2
print(x3, y3, x4, y4)

Solution (Python):
a,b,c,d = map(int, input().split())
x = c-a
y = d-b
print(c-y,d+x,a-y,b+x)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
dx = x2-x1
dy = y2-y1
x3 = x2-dy
y3 = y2+dx
x4 = x1-dy
y4 = y1+dx
print (x3,y3,x4,y4)

Solution (Python):
x1,y1,x2,y2=map(int,input().split())
dx=abs(x1-x2)
dy=abs(y1-y2)
if x1<x2 and y1<=y2:
    x3=x2-dy
    y3=y2+dx
    x4=x3-dx
    y4=y3-dy
elif x1>=x2 and y1<y2:
    x3=x2-dy
    y3=y2-dx
    x4=x3+dx
    y4=y3-dy
elif x1>x2 and y1>=y2:
    x3=x2+dy
    y3=y2-dx
    x4=x3+dx
    y4=y3+dy
elif x1<=x2 and y1>y2:
    x3=x2+dy
    y3=y2+dx
    x4=x3-dx
    y4=y3+dy
else:
    print("NA")
print(x3,y3,x4,y4)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

x3,y3,x4,y4 = 0, 0, 0, 0

x3 = x2 + (y1 - y2)
y3 = y2 - (x1 - x2)
x4 = x1 + (y1 - y2)
y4 = y1 - (x1 - x2)

print(x3,y3,x4,y4)

Solution (Python):
def main():
    x1, y1, x2, y2 = map(int, input().split(" "))
    dx = x2 - x1
    dy = y2 - y1
    print(x2 - dy, y2 + dx, x1 - dy, y1 + dx)
    
    


if __name__ == '__main__':
    main()

Solution (Python):
x1,y1,x2,y2 = list(map(int,input().split()))

x3 = x2 - (y2-y1)
y3 = y2 - (x1-x2)
x4 = x1 - (y2-y1)
y4 = y1 - (x1-x2)

print(x3,y3,x4,y4)

Solution (Python):
x1,y1,x2,y2=map(int,input().split())
print((x2-(y2-y1)),(y2-(x1-x2)),(x1-(y2-y1)),(y1-(x1-x2)))

Solution (Python):
A = list(map(int, input().split()))
L = len(A)
ans = [0, 0, 0, 0]
dx = A[2] - A[0]
dy = A[3] - A[1]
if(dx>=0 and dy>=0):
    dx = abs(dx)
    dy = abs(dy)
    x3 = A[2] - dy
    y3 = A[3] + dx
    x4 = x3 - dx
    y4 = y3 - dy
elif(dx>0 and dy<0):
    dx = abs(dx)
    dy = abs(dy)
    x3 = A[2] + dy
    y3 = A[3] + dx
    x4 = x3 - dx
    y4 = y3 + dy
elif(dx<=0 and dy<=0):
    dx = abs(dx)
    dy = abs(dy)
    x3 = A[2] + dy
    y3 = A[3] - dx
    x4 = x3 + dx
    y4 = y3 + dy
elif(dx<0 and dy>0):
    dx = abs(dx)
    dy = abs(dy)
    x3 = A[2] - dy
    y3 = A[3] - dx
    x4 = x3 + dx
    y4 = y3 - dy

ans[0] = str(x3)
ans[1] = str(y3)
ans[2] = str(x4)
ans[3] = str(y4)
ans = ' '.join(ans)
print(ans)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

x = x2 - x1
y = y2 - y1

print(x2 - y, y2 + x, x1 - y, y1 + x)

Solution (Python):
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
ans=[x3,y3,x4,y4]
print(' '.join(map(str, ans)))

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

if x1 <= x2:
    if y1 < y2:
        print(x2 - (y2 - y1), y2 + (x2 - x1), x1 - (y2 - y1), y1 + (x2 - x1))
    else:
        print(x2 + (y1 - y2), y2 + (x2 - x1), x1 + (y1 - y2), y1 + (x2 - x1))
else:
    if y1 < y2:
        print(x2 - (y2 - y1), y2 - (x1 - x2), x1 - (y2 - y1), y1 - (x1 - x2))
    else:
        print(x2 + (y1 - y2), y2 - (x1 - x2), x1 + (y1 - y2), y1 - (x1 - x2))

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

Solution (Python):
x1, y1, x2, y2 = 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)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
x3 = x2 + (y1-y2)
y3 = y2 - (x1-x2)
x4 = x1 + (y1-y2)
y4 = y1 - (x1-x2)
lst = [x3, y3, x4, y4]
print(*lst)

Solution (Python):
x1,y1,x2,y2=map(int,input().split())
x3=x2-(y2-y1)
y3=y2+(x2-x1)
x4=x1+(y1-y2)
y4=y1-(x1-x2)
lst=[x3,y3,x4,y4]
print(*lst)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
s1, s2 = x2 - x1, y2 - y1
print(x2 - s2, y2 + s1, x1 - s2, y1 + s1)

Solution (Python):

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

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

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

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

dis_x = x1 - x2
dis_y = y1 - y2

x3 = x2 + dis_y
y3 = y2 - dis_x

x4 = x3 + dis_x
y4 = y3 + dis_y

print(x3, y3, x4, y4)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

dif_x = x2 - x1
dif_y = y2 - y1

print(x2 - dif_y, y2 + dif_x, x2 - dif_x - dif_y, y2 + dif_x - dif_y)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

inc_x = x2 - x1
inc_y = y2 - y1
l = max(abs(inc_x), abs(inc_y))

if x1 == x2 and y1 > y2:
    print(x2 + l, y2, x1 + l, y1)
elif x1 == x2:
    print(x2 - l, y2, x1 - l, y1)
elif y1 == y2:
    print(x2, y2 - l, x1, y1 - l)
else:
    print(x2 - inc_y, y2 + inc_x, x1 - inc_y, y1 + inc_x)

Solution (Python):



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

Solution (Python):
x1,y1,x2,y2 = map(int, input().split())

X = x2 - x1
Y = y2 - y1
print(x2-Y,y2+X,x2-Y-X,y2+X-Y)

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

Solution (Python):
a,b,c,d=list(map(int,input().split()))
x=c-a
y=d-b
print(c-y,d+x,a-y,b+x)

Solution (Python):
import math

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

Solution (Python):
x1,y1,x2,y2, = map(int,input().split())
p1 = x1 + y1 * 1j
p2 = x2 + y2 * 1j
vec12 = p2 - p1
p3 = p2 + vec12 * (1j)
p4 = p1 - vec12 * (-1j)
print('{} {} {} {}'.format(int(p3.real), int(p3.imag), int(p4.real), int(p4.imag)))

Solution (Python):
x1,y1,x2,y2 = map(int, input().split())

print(x2 - (y2 - y1), y2 + (x2 - x1), - (y2 - y1) + x1, (x2 - x1) + y1)

Solution (Python):
def solve(x1, y1, x2, y2):
    d1, d2 = x1 - x2, y1 - y2
    x3, y3 = x2 + d2, y2 - d1
    x4, y4 = x3 + d1, y3 + d2
    return '{} {} {} {}'.format(x3, y3, x4, y4)

_x1, _y1, _x2, _y2 = map(int, input().split())
print(solve(_x1, _y1, _x2, _y2))

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

Solution (Python):
def rotate_counter(vec):
  return (-vec[1], vec[0])


def apply(point, vec):
  return (point[0] + vec[0], point[1] + vec[1])


def main():
  (x1, y1, x2, y2) = map(int, input().split())
  vec = (x2 - x1, y2 - y1)

  vec = rotate_counter(vec)
  (x3, y3) = apply((x2, y2), vec)

  vec = rotate_counter(vec)
  (x4, y4) = apply((x3, y3), vec)

  print(x3, y3, x4, y4)


if __name__ == '__main__':
  main()

Solution (Python):
nums = input().split()
x1 = int(nums[0])
y1 = int(nums[1])
x2 = int(nums[2])
y2 = int(nums[3])

X = x2 - x1
Y = y2 - y1

x3 = x2 - Y
y3 = y2 + X

x4 = x3 - X
y4 = y3 - Y

print(x3, y3, x4, y4)

Solution (Python):

import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
x1,y1,x2,y2 = map(int,input().split())
x3 = x2 - (y2-y1)
y3 = y2 + (x2-x1)
x4 = x1 - (y2-y1)
y4 = y1 + (x2-x1)
print(x3,y3,x4,y4)

Solution (Python):
import sys

read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines








def main():
	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)
	
	
	
	
	
	
	


if __name__ == "__main__":
	main()

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
dx = x2-x1
dy = y2-y1
x3, y3 = x2 - dy, y2 + dx
x4, y4 = x3 - dx, y3 - dy 
print(x3,y3,x4,y4)

Solution (Python):
"""
author : halo2halo
date : 23, Jan, 2020
"""

import sys




read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

x1, y1, x2, y2 = map(int, readline().split())
dx, dy = x2 - x1, y2 - y1

x3, y3 = x1 + dx - dy, y1 + dy + dx
x4, y4 = x1 - dy, y1 + dx

print(x3, y3, x4, y4)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

diff_x = (x2-x1) 
diff_y = (y2-y1) 

x3 = x2-diff_y
y3 = y2+diff_x

x4 = x1-diff_y
y4 = y1+diff_x

print(x3,y3,x4,y4)

Solution (Python):
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
def input(): return sys.stdin.readline().rstrip()

def main():
    a,b,c,d=map(int,input().split())
    l=[a-c,d-b]
    ans1=[c-l[1],d-l[0]]
    ans2=[a-l[1],b-l[0]]
    print(*(ans1+ans2))

if __name__ == '__main__':
    main()

Solution (Python):
x1, y1, x2, y2 = [int(i) for i in input().split()]
dx = x2 - x1
dy = y2 - y1
ans = x2 - dy, y2 + dx, x1 - dy, y1 + dx
print(*ans)

Solution (Python):
x1, y1, x2, y2 = 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)

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

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

Solution (Python):
xyList = list(map(int,input().split()))
x = xyList[2]-xyList[0]
y = xyList[3]-xyList[1]
print(xyList[2]-y,xyList[3]+x,xyList[0]-y,xyList[1]+x)

Solution (Python):

x1, y1, x2, y2 = map(int, input().split())

x = x2 - x1
y = y2 - y1

print(x2 - y, y2 + x, x1 - y, y1 + x)

Solution (Python):
import sys

INPUT = lambda: sys.stdin.readline().rstrip()
MAP = lambda: map(int, INPUT().split())

sys.setrecursionlimit(10 ** 9)


def main():
    x1, y1, x2, y2 = MAP()
    print(x2 - (y2 - y1), y2 + (x2 - x1), x1 - (y2 - y1), y1 + (x2 - x1))


if __name__ == '__main__':
    main()

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

Solution (Python):
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)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

x3 = x2 - (y2 - y1)
y3 = y2 + (x2 - x1)

x4 = x1 - (y2 - y1)
y4 = y1 + (x2 - x1)

print(x3, y3, x4, y4)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

X = x2 - x1
Y = y2 - y1

print((x2-Y),(y2 + X),(x1-Y),(y1 + X))

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

dx = x2 - x1
dy = y2 - y1
print(x2-dy, y2+dx, x1-dy, y1+dx)

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

Solution (Python):
x1, y1, x2, y2 = list(map(int, input().split()))
diff_x = x2 - x1
diff_y = y2 - y1
x3 = x2 - diff_y
y3 = y2 + diff_x
x4 = x1 - diff_y
y4 = y1 + diff_x
print(" ".join(map(str,[x3, y3, x4, y4])))

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

x = x2 - x1
y = y2 - y1
print(x2 - y, y2 + x, x1 - y, y1 + x)

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

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

Solution (Python):
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)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
vx = x2 - x1
vy = y2 - y1
vx, vy = -vy, vx
x3 = x2 + vx
y3 = y2 + vy
vx, vy = -vy, vx
x4 = x3 + vx
y4 = y3 + vy
print(x3, y3, x4, y4)

Solution (Python):
import sys

x1, y1, x2, y2 = map(int, sys.stdin.readline().split())

def main():
    x3 = x2 + (y1 - y2)
    y3 = y2 - (x1 - x2)
    x4 = x1 + (y1 - y2)
    y4 = y1 - (x1 - x2)
    return x3, y3, x4, y4

if __name__ == '__main__':
    ans = main()
    print(*ans, sep=' ')

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

yoko = x2 - x1
tate = y2 - y1

x3 = x2 - tate
y3 = y2 + yoko 

x4 = x3 - yoko
y4 = y3 - tate

print(x3,y3,x4,y4)

Solution (Python):

x1,y1,x2,y2 = map(int,input().split())

"""
x3 = x2 - y2 + y1
y3 = y2 - x1 + x2
x4 = x3 - x2 + x1 = x2 - y2 + y1 - x2 + x1
y4 = y3 - y2 + y1 = y2 - x1 + x2 - y2 + y1
"""

x3 = x2 - y2 + y1
y3 = y2 - x1 + x2
x4 = x2 - y2 + y1 - x2 + x1
y4 = y2 - x1 + x2 - y2 + y1

print(x3,y3,x4,y4)

Solution (Python):

x1,y1,x2,y2 = map(int,input().split())

"""
x3 = x2 - y2 + y1
y3 = y2 - x1 + x2
x4 = x3 - x2 + x1 = x2 - y2 + y1 - x2 + x1
y4 = y3 - y2 + y1 = y2 - x1 + x2 - y2 + y1
"""

x3 = x2 - y2 + y1
y3 = y2 - x1 + x2
x4 = x2 - y2 + y1 - x2 + x1
y4 = y2 - x1 + x2 - y2 + y1

print(x3,y3,x4,y4)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
X = x2 - x1
Y = y2 - y1

if x2 > x1 or y2 > y1:
  x3, y3 = x2 - Y, y2 + X
  x4, y4 = x3 - X, y3 - Y

else:
  x3, y3 = x2 + abs(Y), y2 + X
  x4, y4 = x3 - X, y3 + abs(Y)

print(x3, y3, x4, y4)

Solution (Python):
x1,y1,x2,y2 = list(map(int,input().split()))
xdis = x2-x1
ydis = y2-y1
print(x2-ydis,y2+xdis,x1-ydis,y1+xdis)

Solution (Python):
import sys
input = sys.stdin.readline
xy = list(map(int, input().split()))
print(xy[1]-xy[3]+xy[2], -xy[0]+xy[2]+xy[3], xy[0]-xy[3]+xy[1], xy[2]-xy[0]+xy[1])

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

Solution (Python):
x1,y1,x2,y2=map(int, input().split())  

print(x2+(y1-y2),y2-(x1-x2),x1+(y1-y2),y1-(x1-x2))

Solution (Python):


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

w=c-d+b
x=c+d-a
y=a-(d-b)
z=c-a+b
print(w,x,y,z)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

a = x2-x1
b = y2-y1

print(x2-b, y2+a, x1-b, y1+a)

Solution (Python):
x1,y1,x2,y2 = map(int, input().split())
dx = x2 -x1
dy = y2 -y1
x3 = x2 -dy
y3 = y2 +dx
x4 = x1 -dy
y4 = y1 +dx
print(x3, y3, x4, y4)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

if x1 >= x2 and y1 >= y2:
    x3 = x2 + (y1 - y2)
    y3 = y2 - (x1 - x2)
    x4 = x3 + (x1 - x2)
    y4 = y3 + (y1 - y2)
elif x1 >= x2 and y1 < y2:
    x3 = x2 - (y2 - y1)
    y3 = y2 - (x1 - x2)
    x4 = x3 + (x1 - x2)
    y4 = y3 - (y2 - y1)
elif x1 < x2 and y1 >= y2:
    x3 = x2 + (y1 - y2)
    y3 = y2 + (x2 - x1)
    x4 = x3 - (x2 - x1)
    y4 = y3 + (y1 - y2)
else:
    x3 = x2 - (y2 - y1)
    y3 = y2 + (x2 - x1)
    x4 = x3 - (x2 - x1)
    y4 = y3 - (y2 - y1)

print("{} {} {} {}".format(x3, y3, x4, y4))

Solution (Python):
import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7


x1, y1, x2, y2 = list(map(int, sys.stdin.buffer.readline().split()))

c1 = complex(x1, y1)
c2 = complex(x2, y2)
c3 = c2 + (c2 - c1) * 1j
c4 = c3 + (c3 - c2) * 1j
print(int(c3.real), int(c3.imag), int(c4.real), int(c4.imag))

Solution (Python):
x_1, y_1, x_2, y_2 = map(int, input().split())
X = x_2 - x_1
Y = y_2 - y_1
x_3 = x_2 - Y
y_3 = y_2 + X
x_4 = x_3 - X
y_4 = y_3 - Y
print(x_3, y_3, x_4, y_4)

Solution (Python):


(x1, y1, x2, y2) = [int(i) for i in input().rstrip().split(" ")]

(x3, y3, x4, y4) = [0,0,0,0]
if x1 == x2:
    x3 = x1 - (y2 - y1)
    y3 = y2
    x4 = x3
    y4 = y1

elif y1 == y2:
    x3 = x2
    y3 = y2 + (x2 - x1)
    x4 = x1
    y4 = y3
else:
    x_diff = x2 - x1
    y_diff = y2 - y1
    x3 = x2 - y_diff
    y3 = y2 + x_diff
    x4 = x3 - x_diff
    y4 = y3 - y_diff

print(" ".join([str(i) for i in [x3, y3, x4, y4]]))

Solution (Python):
import numpy as np

x1, y1, x2, y2 = map(int, input().split())

a = np.array([[x1], [y1]])
b = np.array([[x2], [y2]])

rot = np.array([[0, -1], [1, 0]])
ab = b - a
bc = np.dot(rot, ab)

c = b + bc
d = a + bc




print(*c.flatten(), end=" ")
print(*d.flatten())

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

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

print(x3,y3,x4,y4)

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

Solution (Python):
x1,y1,x2,y2 = [int(x) for x in input().split()]

A=x2-x1
B=y2-y1

x3 = x2 - B
y3 = y2 + A

x4 = x1 - B
y4 = y1 + A


print(x3,y3,x4,y4)

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

Solution (Python):
x1, y1 ,x2 ,y2 = map(int, input().split())
lst = []

lst.append(y1-y2+x2)
lst.append(x2-x1+y2)
lst.append(x1+y1-y2)
lst.append(y1+x2-x1)

for i in range(4):
    print(lst[i], end=' ')

Solution (Python):
x1,y1,x2,y2 = map(int,input().split())

x = x2 - x1
y = y2 - y1

print(x2-y,y2+x,x1-y,y1+x)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
a = y2 - y1
b = x2 - x1

x3 = x2 - a
y3 = y2 + b
x4 = x1 - a
y4 = y1 + b
print(x3, y3, x4, y4)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

if x1 >= x2 and y1 >= y2:
    x3 = x2 - (y2 - y1)
    y3 = y2 + (x2 - x1)
    x4 = x1 - (y2 - y1)
    y4 = y1 + (x2 - x1)
elif x1 >= x2 and y1 < y2:
    x3 = x2 + (y1 - y2)
    y3 = y2 + (x2 - x1)
    x4 = x1 + (y1 - y2)
    y4 = y1 + (x2 - x1)
elif x1 < x2 and y1 >= y2:
    x3 = x2 - (y2 - y1)
    y3 = y2 - (x1 - x2)
    x4 = x1 - (y2 - y1)
    y4 = y1 - (x1 - x2)
elif x1 < x2 and y1 < y2:
    x3 = x2 + (y1 - y2)
    y3 = y2 - (x1 - x2)
    x4 = x1 + (y1 - y2)
    y4 = y1 - (x1 - x2)

print(str(x3) + " " + str(y3) + " " + str(x4) + " " + str(y4))

Solution (Python):
a,b,c,d=map(int,input().split())
x=c-a
y=d-b
print("{} {} {} {}".format(c-y,d+x,a-y,b+x))

Solution (Python):
x1,y1,x2,y2 = map(int,input().split())

x4 = x1-(y2-y1)
y4 = y1+(x2-x1)
x3 = x4+(x2-x1)
y3 = y4+(y2-y1)

print(x3,y3,x4,y4)

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

Solution (Python):
x_1, y_1, x_2, y_2 = map(int,input().split())

diff_x = x_2 - x_1
diff_y = y_2 - y_1

x_3 = x_2 - diff_y
y_3 = y_2 + diff_x

x_4 = x_3 - diff_x
y_4 = y_3 - diff_y

print(x_3,y_3,x_4,y_4)

Solution (Python):
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)

Solution (Python):
import sys
input = sys.stdin.readline
x1, y1, x2, y2 = [int(x) for x in input().split()]
x_ = x2 - x1
y_ = y2 - y1
x3 = x1 - y_
y3 = y1 + x_
x4 = x3 + x_
y4 = y3 + y_
print(* [x4, y4, x3, y3])

Solution (Python):
N = list(map(int,input().split()))
x = N[2] - N[0]
y = N[3] - N[1]
for i in range(0,3,2):
	N[i]-=y
	N[i+1]+=x
print(N[2],end=" ")
print(N[3],end=" ")
print(N[0],end=" ")
print(N[1],end=" ")

Solution (Python):
X1, Y1, X2, Y2 = map(int, input().split())
X3, Y3 = X2-(Y2-Y1), Y2+(X2-X1)
X4, Y4 = X3-(Y3-Y2), Y3+(X3-X2)
print(X3, Y3, X4, Y4)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

x3 = x2 - (y2 - y1)
y3 = y2 + (x2 - x1)

x4 = x1 - (y2 - y1)
y4 = y1 + (x2 - x1)
print(x3, y3, x4, y4)

Solution (Python):
x1,y1,x2,y2=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)

Solution (Python):
x1,y1,x2,y2=map(int,input().split())
ans=[]
x3=x2-y2+y1
y3=y2+x2-x1
ans.append(x2-y2+y1)
ans.append(y2+x2-x1)
ans.append(x3-y3+y2)
ans.append(y3+x3-x2)
print(*ans)

Solution (Python):
def main():
    x1, y1, x2, y2 = map(int, input().split())
    y = y2-y1
    x = x2-x1
    print(x2-y, y2+x, x1-y, y1+x)

if __name__ == '__main__':
    main()

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

Solution (Python):
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)

Solution (Python):
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)

Solution (Python):
import sys
x1, y1, x2, y2 = map(int, sys.stdin.readline().split())

dx = x2 - x1
dy = y2 - y1

dx1, dy1 = -dy, dx
dx2, dy2 = -dy1, dx1

print(x2+dx1, y2+dy1, x2+dx1+dx2, y2+dy1+dy2)

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
mod2 = 998244353
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))

x1,y1,x2,y2 = inpl()
X = x2-x1
Y = y2-y1
x3,y3 = x2-Y,y2+X
x4,y4 = x1-Y,y1+X
print(x3,y3,x4,y4)

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

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
xd = x2 - x1
yd = y2 - y1
x3 = x2 - yd
y3 = y2 + xd
x4 = x1 - yd
y4 = y1 + xd
print(x3,y3,x4,y4)

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

Solution (Python):
x1,y1,x2,y2 = map(int, input().split())

x3 = x2 + (y1-y2)
y3 = y2 + (x2-x1)

x4 = x1 + (y1-y2)
y4 = y1 + (x2-x1)

print(x3,y3,x4,y4)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())

dx = x2 - x1
dy = y2 - y1

x3, y3 = x2-dy, y2+dx
x4, y4 = x1-dy, y1+dx

print(x3, y3, x4, y4)

Solution (Python):
x1,y1,x2,y2 = list(map(int, input().split()))

x = x2 - x1
y = y2 - y1

print(x2 - y, y2 + x, x1 - y, y1 + x)

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

Solution (Python):
x1, y1, x2, y2 = map(int,input().split())
x3 = x2 + y1 -y2
y3 = y2 + x2 - x1
x4 = x1 + y1 - y2
y4 = y1 + x2 - x1
Answer = [x3, y3, x4, y4]
print(*Answer)

Solution (Python):
a,b,c,d=map(int, input().split())
print(c-(d-b),end=" ")
print((c-a)+d,end=" ")
print((c-(d-b))-(c-a),end=" ")
print(((c-a)+d)-(d-b),end=" ")

Solution (Python):
a, b, c, d = map(int, input().split())

x = c-a
y = d-b

for el in [c-y, d+x, a-y , b+x]:
    print(el, end=" ")

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

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

Solution (Python):
import numpy as np
a,b,c,d=map(int,input().split())
n=np.array([c-a,d-b])
p=np.array([-n[1],n[0]])
print(*([c,d]+p), end=" ") 
print(*([a,b]+p))

Solution (Python):
x1,y1,x2,y2 = map(int,input().split())

a,b = x2-x1,y2-y1

x3,y3 = x1+(a-b),y1+(a+b)
x4,y4 = x2-(a+b),y2+(a-b)

print(x3,y3,x4,y4)

Solution (Python):
data = list(map(int, input().split()))

a = data[2]-data[0]
b = data[3]-data[1]

x3 = data[2]-b
y3 = data[3]+a
x4 = x3-a
y4 = y3-b
print(str(x3)+" "+str(y3)+" "+str(x4)+" "+str(+y4))

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

Solution (Python):
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)

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

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

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
vec_x = x2 - x1
vec_y = y2 - y1
print("{} {} {} {}".format(x2-vec_y, y2+vec_x, x1-vec_y, y1+vec_x))

Solution (Python):
x1, x2, y1, y2 = map(int, input().split())
x = y1 - x1
y = y2 - x2
print("{} {} {} {}".format(y1 - y , y2 + x , x1 - y , x2 + x))

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

Solution (Python):
def rect(x1,x2,y1,y2):
    dx = x2-x1
    dy = y2-y1
    ddx = -dy
    ddy = dx
    x3 = x2 + ddx
    y3 = y2 + ddy
    x4 = x1 + ddx
    y4 = y1 + ddy
    return [x3,y3,x4,y4]

x1,y1,x2,y2 = map(int,input().split())

print(*rect(x1,x2,y1,y2))

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

Solution (Python):
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)

Solution (Python):
x1, y1, x2, y2 = map(int,input().split())

a, b = x2 - x1, y2 - y1
x3, y3 = x2 - b, y2 + a
x4, y4 = x3 - a, y3 - b

print(x3, y3, x4, y4)

Solution (Python):
x1,y1,x2,y2 = map(int,input().split())

x3 = x2 - (y2-y1)
y3 = y2 + (x2-x1)

x4 = x3 - (x2-x1)
y4 = y3 - (y2-y1)

print(x3,y3,x4,y4)

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