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):
ri = lambda: int(input())
rl = lambda: list(map(int,input().split()))
rr = lambda N: [ri() for _ in range(N)]
YN = lambda b: print('YES') if b else print('NO')
yn = lambda b: print('Yes') if b else print('No')
OE = lambda x: print('Odd') if x%2 else print('Even')
INF = 10**18

a,b,c,d=rl()
v2_1 = [a-c,b-d]
v2_3 = [v2_1[1],-v2_1[0]]
x3 = c+v2_3[0]
y3 = d+v2_3[1]
x4 = x3+v2_1[0]
y4 = y3+v2_1[1]

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())
z=((x2-x1)+(y2-y1)*1j)
z3=z*1j+(x2+y2*1j)
z4=z*1j+(x1+y1*1j)
x3,y3=int(z3.real),int(z3.imag)
x4,y4=int(z4.real),int(z4.imag)
print(x3,y3,x4,y4)

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

Solution (Python):
def calc_orthogonal_vect(x1: int, y1: int, x2: int, y2: int)->tuple:
    if x1 == x2:
        return x2 - (y2 - y1), y2

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


def ruined_square(x1: int, y1: int, x2: int, y2: int)->tuple:
    x3, y3 = calc_orthogonal_vect(x1, y1, x2, y2)
    x4, y4 = calc_orthogonal_vect(x2, y2, x3, y3)

    return x3, y3, x4, y4


if __name__ == "__main__":
    x1, y1, x2, y2 = map(int, input().split())
    x3, y3, x4, y4 = ruined_square(x1, y1, x2, y2)
    print(x3, y3, x4, y4)

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

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

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

Solution (Python):
x1,y1,x2,y2 = map(int,input().split())
t = x2-x1
s = y2-y1
x3 = x2-s
y3 = y2 + t
x4 = x1-s
y4 = y1 + t
print("{} {} {} {}".format(x3,y3,x4,y4))

Solution (Python):


"""
Created on 2019/3/
Solved on 2019/3/
@author: shinjisu
"""




import numpy as np


def getInt(): return int(input())



def getIntList(): return np.array(input().split(), dtype=np.longlong)



def zeros(n): return np.zeros(n, dtype=np.longlong)



def getIntLines(n):
    data = zeros(n)
    for i in range(n):
        data[i] = getInt()
    return data


def getIntMat(n, m):  
    mat = zeros((n, m))
    dmp(mat)
    for i in range(n):
        mat[i] = getIntList()
    return mat





ALPHABET = [chr(i+ord('a')) for i in range(26)]
DIGIT = [chr(i+ord('0')) for i in range(10)]
N1097 = 10**9 + 7
INF = 10**18


def dmp(x, cmt=''):
    global debug
    if debug:
        if cmt != '':
            print(cmt, ':  ', end='')
        print(x)
    return x


def prob_B():
    x1, y1, x2, y2 = getIntList()
    dmp((x1, y1, x2, y2))
    dx = x2-x1
    dy = y2-y1
    dmp((dx, dy), 'dx, dy')
    dx, dy = -dy, dx
    dmp((dx, dy), 'dx, dy')
    x3, y3 = x2+dx, y2+dy
    dmp((x3, y3), 'x3, y3')
    dx, dy = -dy, dx
    x4, y4 = x3+dx, y3+dy
    return x3, y3, x4, y4


debug = False  
ans = prob_B()



for elm in ans:
    print(elm, end=' ')

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('{} {} {} {}'.format(x3, y3, x4, y4))

Solution (Python):
x1,  y1,  x2, y2 = map(int, input().split())
z3 = ((x1 - x2) + (y1 - y2)*1j) * -1j + (x2 + y2*1j)
x3, y3 = int(z3.real), int(z3.imag)
z4 = ((x2 - x3) + (y2 - y3)*1j) * -1j + (x3 + y3*1j)
x4 , y4 = int(z4.real), int(z4.imag)
print(x3, y3, x4, y4)

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

dx1 = x2 - x1
dy1 = y2 - y1

dx2 = -dy1
dy2 = dx1

x3 = x2 + dx2
y3 = y2 + dy2
x4 = x3 - dx1
y4 = y3 - dy1

print(x3, y3, x4, y4)

Solution (Python):
import numpy as np
x1, y1, x2, y2 = map(int, input().split())
p1=np.array([x1, y1])
p2 = np.array([x2, y2])
v21=p1-p2
p3=np.dot(np.array([[0,1],[-1,0]]), v21)+p2
p4=p3+v21
print(p3[0], p3[1], p4[0], p4[1])

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('%d %d %d %d' % (x3,y3,x4,y4))

Solution (Python):

x1, y1, x2, y2 = [int(x) for x in 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())
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),x2-x1+y1)

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

x3=x2+(y1-y2)
y3=y2+(x2-x1)
x4=x3+(y2-y3)
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 = x3 + (y2 -y3)
y4 = y3 - (x2 -x3)

print(x3,y3,x4,y4)

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())
print(x2-(y2-y1),y2+(x2-x1),x1-(y2-y1),x2-x1+y1)

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 math

def B():
    a = [int(i) for i in input().split()]
    x = [a[0], a[2]]
    y = [a[1], a[3]]
    x3 = x[1] - (y[1] - y[0])
    y3 = y[1] + (x[1] - x[0])
    x4 = x[0] - (y[1] - y[0])
    y4 = y[0] + (x[1] - x[0])
    print("{} {} {} {}".format(x3, y3, x4, y4))

if __name__ == '__main__':
    B()

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())
n = x2 - x1
m = y2 - y1
x3 = x2 - m
y3 = y2 + n
x4 = x3 - n
y4 = y3 - m
print("{0} {1} {2} {3}".format(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())
print(x2-(y2-y1),y2-(x1-x2),x1-(y2-y1),y1-(x1-x2))

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


if __name__ == "__main__":
    main()

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

vec_x = x2-x1
vec_y = y2-y1
x3,y3 = (x2-vec_y, y2+vec_x)
x4,y4 = (x3-vec_x, y3-vec_y)
print("{} {} {} {}".format(x3,y3,x4,y4))

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

def rot90(vec):
    return [-vec[1], vec[0]]

vec12 = [x2-x1, y2-y1]
vec23 = rot90(vec12)
vec34 = rot90(vec23)
x3 = x2 + vec23[0]
y3 = y2 + vec23[1]
x4 = x3 + vec34[0]
y4 = y3 + vec34[1]

print(x3, y3, x4, y4)

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

x = x1 - x2
y = y1 - y2

print('{} {} {} {}'.format(x2+y, y2-x, x1+y, y1-x))

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

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

x3 = x2 - (y2-y1)
y3 = y2 + (x2-x1)
x4 = x3 - (x2-x1)
y4 = y3 - (y2-y1)
print(str(x3) + " "  + str(y3) + " "  + str(x4) + " "  + str(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())
a,b=x2-x1,y2-y1
print(x2-b,y2+a,x2-b-a,y2+a-b)

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

Solution (Python):
x1, y1, x2, y2 = map(int, raw_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):
def main():
    x1, y1, x2, y2 = map(int, input().split())
    a, b = x1 - x2, y1 - y2
    x3, y3 = x2 + b, y2 - a
    x4, y4 = x3 + a, y3 + b
    print(x3, y3, x4, y4)


if __name__ == "__main__":
    main()

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

disx = x2 - x1
disy = y2 - y1

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


print(x3, y3, x4, y4)

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

dx1, dy1 = x1-x2, y1-y2
x3 = dy1 + x2
y3 = -dx1 + y2

dx2, dy2 = x2-x1, y2-y1
x4 = -dy2 + x1
y4 = dx2 + y1

print(x3, y3, x4, y4)

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

Solution (Python):
int_x1, int_y1, int_x2, int_y2 = map(int, input().split())

int_x3 = int_y3 = int_x4 = int_y4 = 0

int_x = int_x2 - int_x1
int_y = int_y2 - int_y1

print(int_x2 - int_y, int_y2 + int_x, int_x1 - int_y, int_y1 + int_x)

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

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

Solution (Python):
def rotate(vec, dir):
	new_vec = []
	if dir == 1:
		new_vec.append(-vec[1])
		new_vec.append(vec[0])
	elif dir == -1:
		new_vec.append(vec[1])
		new_vec.append(-vec[0])

	return new_vec

vecs12 = list(map(int, input().split()))
vec12 = [vecs12[0] - vecs12[2], vecs12[1] - vecs12[3]]
vec21 = [vecs12[2] - vecs12[0], vecs12[3] - vecs12[1]]
vec3 = [vecs12[2] + rotate(vec12, -1)[0], vecs12[3] + rotate(vec12, -1)[1]]
vec4 = [vecs12[0] + rotate(vec21, 1)[0], vecs12[1] + rotate(vec21, 1)[1]]
vecs34 = vec3 + vec4
print(' '.join(map(str, vecs34)))

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):
x, y, xx, yy = input().split()
x = int(x)
y = int(y)
xx = int(xx)
yy = int(yy)

xdiff = (xx-x)
ydiff = (yy-y)

if xdiff <= 0 and ydiff <= 0:
    xdiff = abs(xx-x)
    ydiff = abs(yy-y)
    print(str(xx+ydiff),str(yy-xdiff),str(x+ydiff),str(y-xdiff))
elif 0 <= xdiff and 0 <= ydiff:
    xdiff = abs(xx-x)
    ydiff = abs(yy-y)
    print(str(xx-ydiff),str(yy+xdiff),str(x-ydiff),str(y+xdiff))
elif xdiff <= 0 and 0 <= ydiff:
    xdiff = abs(xx-x)
    ydiff = abs(yy-y)
    print(str(xx-ydiff),str(yy-xdiff),str(x-ydiff),str(y-xdiff))
else:
    xdiff = abs(xx-x)
    ydiff = abs(yy-y)
    print(str(xx+ydiff),str(yy+xdiff),str(x+ydiff),str(y+xdiff))

Solution (Python):


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

x = x2 - x1
y = y2 - y1

print("{} {} {} {}".format(x2 - y, y2 + x, x1 - y, y1 + x))

Solution (Python):


import math
import sys
import heapq
from operator import itemgetter
import itertools
input = sys.stdin.readline











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

mv_x = x2 - x1
mv_y = y2 - y1

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

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

Solution (Python):
z = [int(i) for i in input().split()]
x = z[2] - z[0]
y = z[3] - z[1]
x_3 = [z[2]-y,z[3]+x]
x_4 = [x_3[0]-x,x_3[1]-y]
square = x_3+x_4
for i in square:
    print(i,end=" ")

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):
def main() -> None:
    X1, Y1, X2, Y2 = map(int, input().split())
    X3, Y3 = X2-(Y2-Y1), Y2+(X2-X1)
    X4, Y4 = X3-(X2-X1), Y3-(Y2-Y1)
    print(str(X3) + " " + str(Y3) + " " + str(X4) + " " + str(Y4))


if __name__ == '__main__':
    main()

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())
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):
n = list(map(int,input().split()))
dis_x = abs(n[2]-n[0])
dis_y = abs(n[3]-n[1])
if n[0]<=n[2]:
    if n[1]<=n[3]:
        print(n[2]-dis_y,n[3]+dis_x,n[0]-dis_y,n[1]+dis_x)
    else:
        print(n[2]+dis_y,n[3]+dis_x,n[0]+dis_y,n[1]+dis_x)
elif n[0]>n[2]:
    if n[1]<=n[3]:
        print(n[2]-dis_y,n[3]-dis_x,n[0]-dis_y,n[1]-dis_x)
    else:
        print(n[2]+dis_y,n[3]-dis_x,n[0]+dis_y,n[1]-dis_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):

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("{} {} {} {}".format(x3, y3, x4, y4))

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
x3 = x2 + y1 - y2
y3 = y2 + x2 - x1
x4 = x3 + y2 - y3
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

nx = x2
ny = y2

l = []

for i in range(2):
    dx, dy = -dy, dx

    nx = nx + dx
    ny = ny + dy

    l.append(nx)
    l.append(ny)

print(l[0], l[1], l[2], l[3])

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

dx = x2 - x1
dy = y2 - y1

nx = x2
ny = y2

l = []

for i in range(2):
    dx, dy = -dy, dx

    nx = nx + dx
    ny = ny + dy

    l.append(nx)
    l.append(ny)

print(l[0], l[1], l[2], l[3])

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(str(x3)+" "+str(y3)+" "+str(x4)+" "+str(y4))

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

print(c-ve2,d+ve1,a-ve2,b+ve1)

Solution (Python):
import sys

def main():
  input = sys.stdin.readline
  x1, y1, x2, y2 = map(int, input().split())

  x4 = -(y2 - y1) + x1
  y4 = (x2 - x1) + y1
  x3 = x2 + x4 - x1
  y3 = y2 + y4 - y1
  print('{} {} {} {}'.format(x3, y3, x4, y4))


if __name__ == '__main__':
  main()

Solution (Python):
x,y,xx,yy=[int(i) for i in input().split()]
a=xx-x
b=yy-y
yyy=yy+a
xxx=xx-b
yyyy=yyy-b
xxxx=xxx-a

print(xxx,yyy,xxxx,yyyy)

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

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

print(x3,y3,x4,y4)

Solution (Python):
import math

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):
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("{} {} {} {}".format(x3, y3, x4, y4))

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

x3 = x2-y_margin
y3 = y2 + x_margin

x4 = x3 - x_margin
y4 = y3 - y_margin

print(x3 , end=" ")
print(y3 , end=" ")
print(x4 , end=" ")
print(y4 , end=" ")

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):
if __name__ == "__main__":
    x1, y1, x2, y2 = list(map(int, input().split(" ")))
    m = x2 - x1
    n = y2 - y1
    x3 = x2 - n
    y3 = y2 + m
    x4 = x1 - n
    y4 = y1 + m
    print(x3, y3, x4, y4)

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

Solution (Python):

"""
xy平面上に正方形があり、4つの頂点の座標は反時計回りに順番に(x1,y1),(x2,y2),(x3,y3),(x4,y4)です。
なお、x軸は右向きに、y軸は上向きに取ることにします。
高橋君は、これら4つの座標のうち(x3,y3),(x4,y4)を忘れてしまいました。
x1,x2,y1,y2が与えられるので、x3,y3,x4,y4を復元してください。なお、これらの条件から、
x3,y3,x4,y4は一意に存在し、整数となることが証明できます。
"""
import numpy as np


def get_vector(x1, y1, x2, y2):
    a = np.array([x1, y1])
    b = np.array([x2, y2])
    vector = b - a

    return vector


def get_rotation_matrix(rad):
    """
    指定したradの回転行列を返す
    """
    rot = np.array([[np.cos(rad), -np.sin(rad)],
                  [np.sin(rad), np.cos(rad)]])
    return rot


def main(str):
    coodinate = str.split()

    
    x1 = int(coodinate[0])
    y1 = int(coodinate[1])
    x2 = int(coodinate[2])
    y2 = int(coodinate[3])

    
    vector1 = get_vector(x1, y1, x2, y2)
    
    rotate_matrix = get_rotation_matrix(np.pi/2)
    
    vector2 = np.dot(rotate_matrix, vector1)

    x3 = int(round(vector2[0] + x2))
    y3 = int(round(vector2[1] + y2))
    x4 = int(round(vector2[0] + x1))
    y4 = int(round(vector2[1] + y1))

    print(x3, y3, x4, y4)


if __name__ == "__main__":
    main(input())

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('{} {} {} {}'.format(x3,y3,x4,y4))

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

Solution (Python):
from statistics import mean, median,variance,stdev
import sys
import math
import fractions

def j(q):
    if q==1: print("Yes")
    else:print("No")
    exit(0)


def ct(x,y):
    if (x>y):print("")
    elif (x<y): print("")
    else: print("")

def ip():
    return int(input())




n,m,x,y= (int(i) for i in input().split())  






dx = x-n
dy = y-m
px = x
py = y
a = []
py+=dx
px-=dy
cx=px
cy=py
px-=dx
py-=dy
print(cx,cy,px,py)

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

dy3 = x2 - x1
dx3 = -(y2 - y1)

x3 = x2 + dx3
y3 = y2 + dy3

dx4 =  - (x2 - x1)
dy4 =  - (y2 - y1)


x4 = x3 + dx4
y4 = y3 + dy4


print(x3,y3,x4,y4)

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

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

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

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

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

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

x_dif = x2-x1
y_dif = y2-y1

x4, y4 = x1 - y_dif, y1 + x_dif
x3, y3 = x2 - y_dif, y2 + x_dif

print(x3, y3, x4, y4)

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

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):
x,y,z,w = map(int,input().split())
a = z-x
b = w-y
print(str(z-b)+" "+str(w+a)+" "+str(x-b)+" "+str(y+a))

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())
x_d = x2 - x1
y_d = y2 - y1

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

Solution (Python):
x1,y1,x2,y2=map(int,input().split())
a=abs(x1-x2)
b=abs(y1-y2)
if(y1<=y2):
  if(x1<=x2):
    print(x2-b,y2+a,x1-b,y1+a)
    
  else:
    print(x2-b,y2-a,x1-b,y1-a)
    
else:
  if(x1<=x2):
    print(x2+b,y2+a,x1+b,y1+a)
    
  else:
    print(x2+b,y2-a,x1+b,y1-a)

Solution (Python):
""" AtCoder """

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

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

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

w = abs(x1-x2)
h = abs(y1-y2)

if x1 <= x2 and y1 > y2:
  print(x2 + h, y2 + w, x1 + h, y1 + w)
elif x1 <= x2 and y1 <= y2:
  print(x2- h, y2 + w, x1 - h, y1 + w)
elif x1 > x2 and y1 > y2:
  print(x2 + h, y2 - w, x1 + h, y1 - w)
else:
  print(x2 - h, y2 - w, x1 - h, y1- w)

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(str(x3)+" "+str(y3)+" "+str(x4)+" "+str(y4))

Solution (Python):


def main():
    na = list(map(int, input().split()))
    x1, y1, x2, y2 = na[0], na[1], na[2], na[3]

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

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


if __name__ == '__main__':
    main()

Solution (Python):
def main():
    x1, y1, x2, y2 = map(int, input().split())
    xx = abs(y1 - y2)
    yy = abs(x1 - x2)
    if x1 > x2:
        if y1 > y2:
            print(x2 + xx, y2 - yy, x1 + xx, y1 - yy)
        else:
            print(x2 - xx, y2 - yy, x1 - xx, y1 - yy)
    else:
        if y1 > y2:
            print(x2 + xx, y2 + yy, x1 + xx, y1 + yy)
        else:
            print(x2 - xx, y2 + yy, x1 - xx, y1 + yy)


main()

Solution (Python):


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

tx = y1-y2
ty = x2-x1

print(x2+tx,y2+ty,x1+tx,y1+ty)

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

Solution (Python):


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

ix, iy = (x2 - x1, y2 - y1)

dx, dy = (-iy , ix)
ddx, ddy = (-ix , -iy)

x3, y3 = (x2 + dx, y2 + dy)
x4, y4 = (x3 + ddx, y3 + ddy)

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

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

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

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

Solution (Python):


def main():
    x1, y1, x2, y2 = map(int, input().split())
    d12 = [x2 - x1, y2 - y1]
    d23 = turn_90_degs(d12)
    d34 = turn_90_degs(d23)
    x3 = x2 + d23[0]
    y3 = y2 + d23[1]
    x4 = x3 + d34[0]
    y4 = y3 + d34[1]
    print(x3, y3, x4, y4)

def turn_90_degs(v):
    u = [-v[1], v[0]]
    return u

main()

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

x_idou = x2 - x1
y_idou = y2 - y1

print(x2-y_idou,y2+x_idou,x2-y_idou-x_idou,y2+x_idou-y_idou)

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

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

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

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

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
diff1 = x2 - x1
diff2 = y2 - y1
x3, y3 = x2 - diff2, y2 + diff1
x4, y4 = x3 - diff1, y3 - diff2
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):
x_1, y_1, x_2, y_2 = [int(x) for x in input().split()]
delta_x = x_2 - x_1
delta_y = y_2 - y_1
x_3 = x_2 - delta_y
y_3 = y_2 + delta_x
x_4 = x_3 - delta_x
y_4 = y_3 - delta_y
print(str(x_3) + ' ' + str(y_3) + ' ' + str(x_4) + ' ' + str(y_4))

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

Solution (Python):
x1,y1,x2,y2=(int(i) for i in input().split())
dx = x2-x1
dy = y2-y1
x3 = x2 - dy
y3 = y2 + dx
dx = x3-x2
dy = y3-y2
x4 = x3 - dy
y4 = y3 + dx
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):
def main(x0,y0,x1,y1):
    c0 = complex(x0,y0)
    c1 = complex(x1,y1)
    c = c1 - c0
    c2 = c1 + c *1j
    c3 = c2 +c *(-1)
    x2 = int(c2.real)
    y2 = int(c2.imag)
    x3 = int(c3.real)
    y3 = int(c3.imag)
    return "{} {} {} {}".format(x2,y2,x3,y3)
x0,y0,x1,y1 = map(int,input().split())
print(main(x0,y0,x1,y1))

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

Solution (Python):
x1,y1,x2,y2 = map(int,input().split())
x = x1 - x2 
y = y1 - y2
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, y3 = x2 + y, y2 - x
x4, y4 = x1 + y, y1 - x
print(x3, y3, x4, y4)

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

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

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
dx = abs(x1 - x2)
dy = abs(y1 - y2)
x = 0
y = 0
fx = 1
fy = 1
if y2 < y1:
    if x2 > x1:
        fx = 1
        fy = 1
    else:
        fx = 1
        fy = -1
else:
    if x2 > x1:
        fx = -1
        fy = 1
    else:
        fx = -1
        fy = -1
x = x2 + fx * dy
y = y2 + fy * dx
print(x, y, end = ' ')
x1 = x2
y1 = y2
x2 = x
y2 = y
dx = abs(x1 - x2)
dy = abs(y1 - y2)
if y2 < y1:
    if x2 > x1:
        fx = 1
        fy = 1
    else:
        fx = 1
        fy = -1
else:
    if x2 > x1:
        fx = -1
        fy = 1
    else:
        fx = -1
        fy = -1
x = x2 + fx * dy
y = y2 + fy * dx
print(x, y)

Solution (Python):

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

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

Solution (Python):
a = list(map(int,input().split()))
diffx = a[2]-a[0]
diffy = a[3]-a[1]
print("{} {} {} {}".format(a[2]-diffy, a[3]+diffx, a[0]-diffy, a[1]+diffx))

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
v1 = [x1, y1]
v2 = [x2, y2]
v12 = [v2[0]-v1[0], v2[1]-v1[1]]

def rot(v):
	return [v[1]*(-1), v[0]]

v3 = [v2[0]+rot(v12)[0], v2[1]+rot(v12)[1]]
v23 = [v3[0]-v2[0], v3[1]-v2[1]]
v4 = [v3[0]+rot(v23)[0], v3[1]+rot(v23)[1]]

print(v3[0], v3[1], v4[0], v4[1])

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

x=x2-x1
y=y2-y1

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

Solution (Python):
x3, y3, x4, y4 = map(int, input().split())
changeX = x4 - x3
changeY = y4 - y3
x = x4
y = y4
for _ in range(2):
    temp = changeX
    changeX = changeY * -1
    changeY = temp
    x = x + changeX
    y = y + changeY
    print(x, y, end = ' ')

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):
x1, y1, x2, y2 = [int(x) for x in input().split()]

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

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

print("{} {} {} {}".format(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

dx = x3 - x2
dy = y3 - y2
x4 = x3-dy
y4 = y3+dx

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())
print(x2 - (y2 - y1), y2 + (x2 - x1), x1 - (y2 - y1), y1 + (x2 - x1))

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())
x3 = x2 + (y1 - y2)
y3 = y2 + (x2 - x1)
x4 = x1 + (y1 - y2)
y4 = y1 + (x2 - x1)
print(x3,y3,x4,y4)

Solution (Python):
x_1, y_1, x_2, y_2 = list(map(int, input().split()))
l = [0] * 4
l[0] = x_2 - (y_2 - y_1)
l[1] = y_2 + (x_2 - x_1)
l[2] = l[0] - (x_2 - x_1)
l[3] = l[1] - (y_2 - y_1)
for i in range(4):
    print(l[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 = list(map(int, input().split()))
dx = +(y1-y2)
dy = -(x1-x2)
x3, y3, x4, y4 = x2+dx, y2+dy, x1+dx, y1+dy
print(x3, y3, x4, y4)

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

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

print('{} {} {} {}'.format(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())
vx = x2 - x1
vy = y2 - y1
x3 = -vy + x2
x4 = -vy + x1
y3 = vx + y2
y4 = vx + y1
print(x3, y3, x4, y4)

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


if __name__ == '__main__':
    main()

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

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

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

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

delx = x2-x1
dely = y2-y1

print(x1+delx-dely, y1+dely+delx, x1-dely, y1+delx)

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

diff_x = x2 - x1
diff_y = y2 - y1

x4 = x1 - diff_y
y4 = y1 + diff_x

x3 = x2 - diff_y
y3 = y2 + diff_x

print("{} {} {} {}".format(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())

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

print(x3, y3, x4, y4)

Solution (Python):
from numpy import array
a = list(map(int, input().split()))

x = array([a[0],a[1]])
y = array([a[2],a[3]])
n = array([a[2]-a[0],a[3]-a[1]])
c = n[1]
n[1]=n[0]
n[0]=-c
w = y + n
c = n[1]
n[1]=n[0]
n[0]=-c
z = w + n
k = w[0]
i = w[1]
o = z[0]
p = z[1]
print("{0} {1} {2} {3}".format(k,i,o,p))

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):
x_1,y_1,x_2,y_2=tuple(map(int,input().split()))

be=[x_2-x_1,y_2-y_1]
za3=[x_2+(-1)*be[1],y_2+be[0]]
za4=[x_1+(-1)*be[1],y_1+be[0]]

print(za3[0],za3[1],za4[0],za4[1])

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

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

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

print(x3,y3,x4,y4)

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

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