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

v = [x2 - x1, y2-y1]
rotv = [-v[1],v[0]]

P3 = [x2+rotv[0],y2+rotv[1]]
P4 = [P3[0] - v[0], P3[1] - v[1]]

print(*(P3 + P4))

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

x_diff = x2 - x1
y_diff = y2 - y1

x3 = x2 - y_diff
y3 = y2 + x_diff

x4 = x1 - y_diff
y4 = y1 + x_diff

print(x3, y3, x4, y4)

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

Solution (Python):
"""
【ABC108】
B_Ruined_Square



import sys


def ILI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def ISI(): return map(int, sys.stdin.readline().rstrip().split())
def II(): return int(sys.stdin.readline().rstrip())
def ISS(): return sys.stdin.readline().rstrip().split()
def IS(): return sys.stdin.readline().rstrip()

x1, y1, x2, y2 = ISI()
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())
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, 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, raw_input().split())
lenx = x2-x1
leny = y2-y1
x3 = x2 - leny
y3 = y2 + lenx
x4 = x3 - lenx
y4 = y3 - leny
print x3,
print y3,
print x4,
print y4

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

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

k1=x2-x1
k2=y2-y1

x3=x2-k2
y3=y2+k1

x4=x3-k1
y4=y3-k2

print(x3,y3,x4,y4)

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

Solution (Python):
import numpy as np

a = np.reshape(np.array(list(map(int, input().split()))), (2, 2))


def rotation(x, t, deg = False):
    if deg == True:
        t = np.deg2rad(t)
    a = np.array([[np.cos(t), -np.sin(t)],
                  [np.sin(t),  np.cos(t)]])
    ax = np.dot(a, x)
    return ax


b = a[1] + rotation(a[1] - a[0], 90, deg=True)
c = b + rotation(b - a[1], 90, deg=True)
ans_list = np.hstack((b, c)).tolist()
ans = [round(i) for i in ans_list]

print(' '.join(map(str, 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())
x = x2 - x1
y = y2 - y1
print(x2-y, y2+x, x1-y, y1+x)

Solution (Python):
import math

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

r = (x12**2+y12**2)**(1/2)
θ = math.asin(abs(y12)/r)
if 0 >= x12 and 0 <= y12:
    θ = math.pi - θ
elif 0 >= x12 and 0 > y12:
    θ += math.pi
elif 0 < x12 and y12 < 0:
    θ = 2*math.pi - θ
x3 = round((2**(1/2)*r)*math.cos(θ + (math.pi/4)) + x1)
y3 = round((2**(1/2)*r)*math.sin(θ + (math.pi/4)) + y1)
x4 = round(r*math.cos(θ + (math.pi/2)) + x1)
y4 = round(r*math.sin(θ + (math.pi/2)) + y1)
print(x3,y3,x4,y4)

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 = x3 - dx
y4 = y3 - dy


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

Solution (Python):
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  

x1, y1, x2, y2 = na()
vx, vy = x2 - x1, y2 - y1
e1 = [-vy, vx]
p3 = [x2 + e1[0], y2 + e1[1]]
p4 = [p3[0] - vx, p3[1] - vy]
print(*[p3[0], p3[1], p4[0], p4[1]])

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

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

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

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

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

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

print(' '.join(map(str, [x3, y3, x4, y4])))

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

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

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

xlen=x2-x1
ylen=y2-y1

print(x2-ylen,end=" ")
print(y2+xlen,end=" ")
print(x1-ylen,end=" ")
print(y1+xlen)

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

dx, dy = x2-x1, y2-y1

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

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):
import numpy as np
x1, y1, x2, y2 = map(int, input().split())

a = np.array([x2-x1, y2-y1])
rot = np.array([[0, 1], [-1, 0]])
b = np.dot(a, rot)
print (x2 + b[0], y2 + b[1], x1 + b[0], y1 + b[1])

Solution (Python):
import sys
input=sys.stdin.readline
import math

def main():

    x1,y1,x2,y2 = map(int, input().split())
    t = math.pi/2
    x3 = x2 + (x2-x1) * math.cos(t) - (y2-y1) * math.sin(t)
    y3 = y2 + (x2-x1) * math.sin(t) + (y2-y1) * math.cos(t)
    x4 = x3 + (x3-x2) * math.cos(t) - (y3-y2) * math.sin(t)
    y4 = y3 + (x3-x2) * math.sin(t) + (y3-y2) * math.cos(t)
    print(round(x3), round(y3), round(x4), round(y4))

if __name__ == '__main__':
    main()

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

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):
def test():
    x1,y1,x2,y2 = map(int,input().split())
    x = x2-x1
    y = y2-y1
    print(x2-y,y2+x,x1-y,y1+x)


if __name__ == "__main__":
    test()

Solution (Python):
import math
import numpy as np
x1, y1, x2, y2 = map(int, input().split())
c1 = [x1, y1]
c2 = [x2, y2]
v = [x2-x1, y2-y1]
d = int(math.sqrt(v[0]*v[0] + v[1]*v[1]))
rotate_matrix = ([0, 1], [-1, 0])

v4 = np.dot(v, rotate_matrix)
v3 = [v4[0] + v[0], v4[1] - v[1]]

c4 = c1 + v4
c3 = c2 + v4

print(c3[0],c3[1],c4[0],c4[1])

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

x_diff=x2-x1
y_diff=y2-y1

print("{} {} {} {}".format(x2-y_diff, y2+x_diff, x1-y_diff, y1+x_diff))

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):
def main():
    x1, y1, x2, y2 = map(int, input().split())
    v1 = x2-x1
    v2 = y2-y1
    x3, y3 = x2-v2, y2+v1
    x4, y4 = x3-v1, y3-v2
    return x3, y3, x4, y4

if __name__ == '__main__':
    output = main()
    print(" ".join(map(str, output)))

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, dy=x2-x1, y2-y1

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

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

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

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

x_sa = x2 - x1
y_sa = y2 - y1
print(x2 - y_sa, y2 + x_sa, x1 - y_sa, y1 + x_sa)

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

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

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 = list(map(int, input().split()))
dif = x2-x1
dif2 = y2-y1
l = [x2 - dif2, y2 + dif, x1 - dif2, y1 + dif]
ll = [str(i) for i in l]
print(" ".join(ll))

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

Solution (Python):
import math
import sys
import queue
from collections import Counter
from itertools import accumulate
from fractions import gcd
from functools import reduce


def lcm(a, b):
    return a * b // gcd(a, b)

def combination_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

def permutations_count(n, r):
    return math.factorial(n) // math.factorial(n - r)

sys.setrecursionlimit(10000)

mod = 1000000007

"""

a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654


char_list = list("abcd") 



    = sys.stdin.readline().rstrip()
    = list(sys.stdin.readline().rstrip())


    = int(sys.stdin.readline())
    = map(int, sys.stdin.readline().split())
    = list(map(int, sys.stdin.readline().split()))
    = [list(map(int,list(sys.stdin.readline().split()))) for i in range(N)]
"""

from math import sin
from math import cos
from math import radians as rad
import numpy as np

if __name__ == "__main__":
    x1, y1, x2, y2 = map(int, sys.stdin.readline().split())
    p1 = np.array([x1, y1])
    p2 = np.array([x2, y2])
    Rot = np.array([[cos(rad(90)), -sin(rad(90))], [sin(rad(90)), cos(rad(90))]])

    p3 = np.dot(Rot, p2 - p1) + p2
    p4 = np.dot(Rot, p3 - p2) + p3    
    print(int(round(p3[0])), int(round(p3[1])), int(round(p4[0])), int(round(p4[1])))

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

difx = x2 - x1
dify = y2 - y1

x3, y3 = x2 - dify, y2 + difx
x4, y4 = x1 - dify, y1 + difx

print(x3, y3, x4, y4)

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

x1, y1, x2, y2 = MAP()

a = x2 - x1
b = 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())

d1 = x2-x1
d2 = y2-y1

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

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

print(x3,y3,x4,y4)

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

    x = x2 - x1
    y = y2 - y1

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

main()

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

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

import numpy as np
R=pow((x1-x2)**2+(y1-y2)**2,0.5)
x3=pow(2,0.5)*R/R*(x2-x1-(y2-y1))/pow(2,0.5)+x1
y3=pow(2,0.5)*R/R*(y2-y1+x2-x1)/pow(2,0.5)+y1
x3=int(x3)
y3=int(y3)
x4=-R*(y2-y1)/R+x1
y4=R*(x2-x1)/R+y1
x4=int(x4)
y4=int(y4)
print(x3,y3,x4,y4)

Solution (Python):
def solve():
    x1, y1, x2, y2 = list(map(int, input().split()))
    dx, dy = x2 - x1, y2 - y1
    x3, y3 = x2 - dy, y2 + dx
    x4, y4 = x3 - dx, y3 - dy
    return " ".join([str(i) for i in [x3, y3, x4, y4]])


if __name__ == "__main__":
    print(solve())

Solution (Python):
import sys
input = sys.stdin.readline

L = [int(v) for v in input().split()]

print(L[1] + L[2] - L[3], L[2] - L[0] + L[3], L[1] + L[0] - L[3], L[2] - L[0] + L[1])

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

p1 = (int(n[0]) + int(n[1]) * 1j)
p2 = (int(n[2]) + int(n[3]) * 1j)

p3 = (p2 - p1) * 1j + p2
p4 = p3 + (p1 - p2)

print(int(p3.real), int(p3.imag), int(p4.real), int(p4.imag))

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

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 = x3 - diff_x
y4 = y3 - diff_y

print(x3, y3, x4, y4)

Solution (Python):
x_1,y_1,x_2,y_2=map(int,input().split())
temp = [x_2-x_1,y_2-y_1]
x_3 = x_2 - temp[1]
y_3 = y_2 + temp[0]
x_4 = x_1 - temp[1]
y_4 = y_1 + temp[0]

print(str(x_3) + " " + str(y_3) + " " + str(x_4) + " " + str(y_4))

Solution (Python):

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

c -= a
d -= b
if c > 0 and d >= 0:     
    e = c - d
    f = c + d
    g = -abs(d)
    h = abs(c)
elif c <= 0 and d > 0:       
    e = c - abs(d)
    f = d - abs(c)
    g = -abs(d)
    h = -abs(c)
elif c < 0 and d <= 0:       
    e = c + abs(d)
    f = d - abs(c)
    g = abs(d)
    h = -abs(c)
else:       
    e = c + abs(d)
    f = d + abs(c)
    g = abs(d)
    h = abs(c)

print("{} {} {} {}".format(e+a , f+b , g+a ,h+b))

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

x12 = x2 -x1
y12 = y2 -y1

x3 = x2-y12
y3 = y2+x12

x4 = x1-y12
y4 = y1+x12

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=list(map(int,input().split()))

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

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


vector_x1 = x1 - x2
vector_y1 = y1 - y2

x3 = x2 + vector_y1
y3 = y2 - vector_x1

vector_x2 = x2 - x3
vector_y2 = y2 - y3

x4 = x3 + vector_y2
y4 = y3 - vector_x2

print(x3,y3,x4,y4)

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

Solution (Python):
import math
import copy
import sys

inputa = input().split()










inputaList = [int(n) for n in inputa]
















x1 = inputaList[0]
y1 = inputaList[1]
x2 = inputaList[2]
y2 = inputaList[3]

edgeDisx = x2 - x1
edgeDisy = y2 - y1

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

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

x = x2 - x1
y = y2 - y1
print('{0} {1} {2} {3}'.format(x2 - y, y2 + x, x1 - y, y1 + x))

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

x12 = x2-x1
y12 = y2-y1

x23 = -y12
y23 = x12

x34 = -y23
y34 = x23

x3 = x2 + x23
x4 = x3 + x34
y3 = y2 + y23
y4 = y3 + y34

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)

for item in [x3, y3, x4, y4]:
  print(item, 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())
i = x2-x1
j = y2-y1
print(x2-j, y2+i, x1-j, y1+i)

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

Solution (Python):
import sys
from collections import deque

sys.setrecursionlimit(4100000)


def inputs(num_of_input):
    ins = [input() for i in range(num_of_input)]
    return ins


def _euclid(x, y):
    if x > y:
        large = x
        small = y
    else:
        large = y
        small = x

    if small == 0:
        return large

    return _euclid(small, large % small)


def euclid_multi(nums):
    if len(nums) == 1:
        return nums[0]

    e = -1
    for i in range(1, len(nums)):
        if e == -1:
            e = _euclid(nums[0], nums[1])
        else:
            e = _euclid(e, nums[i])
    return e


def solve(inputs):
    [x1, y1, x2, y2] = string_to_int(inputs[0])
    diff_x = x2 - x1
    diff_y = y2 - y1
    x3 = x2 - diff_y
    y3 = y2 + diff_x
    x4 = x1 - diff_y
    y4 = y1 + diff_x
    return "{} {} {} {}".format(x3, y3, x4, y4)


def string_to_int(string):
    return list(map(int, string.split()))


if __name__ == "__main__":
    ret = solve(inputs(1))
    print(ret)

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

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

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

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

diff_1 = c - a
diff_2 = d - b

e = c - diff_2
f = d + diff_1
g = e - diff_1
h = f - diff_2

print('{} {} {} {}'.format(e,f,g,h))

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

Solution (Python):
import sys
input = sys.stdin.readline
from operator import itemgetter

def rotate(x, y):
	return (-y, x)

def main():
	x1, y1, x2, y2 = map(int, input().strip().split())
	v = (x2-x1, y2-y1)
	lp = (x2, y2)
	for i in range(2):
		v = rotate(v[0], v[1])
		next = lp[0]+v[0], lp[1]+v[1]
		print("{} {} ".format(next[0], next[1]), end="")
		lp = next
	print("")
	
	
	
	
	
	
	
	
	

if __name__ == '__main__':
	main()

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

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

Solution (Python):
x1,y1,x2,y2 = map(int,input().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):
put = list(map(int,input().split()))
xdiff = put[2] - put[0]
ydiff = put[3] - put[1]
zero = put[2:4]
ans = []
for _ in range(2):
  xdiff,ydiff = -ydiff,xdiff
  zero[0] += xdiff
  zero[1] += ydiff
  ans += zero
print(' '.join(list(map(str,ans))))

Solution (Python):


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

xx=x2-x1
yy=y2-y1

x3=x2-yy
y3=y2+xx
x4=x1-yy
y4=y1+xx
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):
words = lambda t : list(map(t, input().split()))
x1,y1,x2,y2 = words(int)

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

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

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

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

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):
a,b,c,d=map(int,input().split())
x=c-a;y=d-b
e=c-y;f=d+x;g=e-x;h=f-y
print(e,f,g,h)

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

s,t = x2-x1, y2-y1

x3,y3 = x2-t, y2+s

s,t = x3-x2, y3-y2

x4,y4 = x3-t, y3+s

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

Solution (Python):

tmp = [int(el) for el in input().split(' ')]

y = tmp[3] - tmp[1]
x = tmp[2] - tmp[0]

print(tmp[2]-y, tmp[3]+x, tmp[0]-y, tmp[1]+x)

Solution (Python):
points = list(map(int, input().split(' ')))
point1 = {'x': points[0], 'y': points[1]}
point2 = {'x': points[2], 'y': points[3]}

delta_x = point2['x'] - point1['x']
delta_y = point2['y'] - point1['y']

point3 = {
  'x': point2['x'] - delta_y,
  'y': point2['y'] - (-delta_x)
}

delta_x = point3['x'] - point2['x']
delta_y = point3['y'] - point2['y']

point4 = {
  'x': point3['x'] - delta_y,
  'y': point3['y'] - (-delta_x)
}

print(point3['x'], point3['y'], point4['x'], point4['y'])

Solution (Python):
if __name__ == '__main__':
    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(str(x3) + " " + str(y3) + " " + str(x4) + " " + str(y4))

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
dx, dy = x2 - x1, 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=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 = map(int, input().split())
x3 = x2 + y1 - y2
y3 = y2 - x1 + x2
x4 = x3 + y2 - y3
y4 = y3 - x2 + x3
print(' '.join( map(str, [x3, y3, x4, y4]) ))

Solution (Python):
l = [int(i) for i in input().split(" ")]
x1 = l[0]
y1 = l[1]
x2 = l[2]
y2 = l[3]
diff_x21 = x2-x1
diff_y21 = y2-y1
y3 = y2 + diff_x21
x3 = x2 - diff_y21
x4 = x3-diff_x21
y4 = y3-diff_y21
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=x3-dx,y3-dy


print(x3,y3,x4,y4)

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

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

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):
x1,y1,x2,y2=map(int, input().split())
xd = x2 - x1
yd = y2 - y1
print(x2 - yd, y2 + xd, x1 - yd, y1 + xd)

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

x=x2-x1
y=y2-y1

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

Solution (Python):
a,b,c,d = map(int,input().split())
import numpy as np
one =[a,b]
two =[c,d]
A = np.array(one)
B = np.array(two)
vec = B-A
C = B+np.array([-vec[1],vec[0]])
D = C+np.array([-vec[0],-vec[1]])
print(C[0],C[1],D[0],D[1])

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

a = (x2 - x1, 0)
b = (0, y2 - y1)

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

x=x2-x1
y=y2-y1

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

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

a = x2 - x1
b = y2 - y1

print(str(x2 - b) + ' ' + str(y2 + a) + ' ' + str(x1 - b) + ' ' + str(y1 + a))

Solution (Python):
li=list(map(int,input().split()))
X=li[2]-li[0]
Y=li[3]-li[1]
L = [li[2]-Y,li[3]+X,li[0]-Y,li[1]+X]
print(' '.join(map(str, L)))

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

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

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

print(x3, y3, x4, y4)

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

anslst = []
anslst.append(inLst[2] - (inLst[3] - inLst[1]))
anslst.append(inLst[3] + (inLst[2] - inLst[0]))
anslst.append(anslst[0] - (inLst[2] - inLst[0]))
anslst.append(anslst[1] - (inLst[3] - inLst[1]))

for i in anslst:
    print(i, end=' ')

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

dx = abs(c - a)
dy = abs(b - d)

if c >= a and d > b:
  e = c - dy
  f = d + dx
  g = e - dx
  h = f - dy
  print(e, f, g, h)
elif c < a and d >= b:
  e = c - dy
  f = d - dx
  g = e + dx
  h = f - dy
  print(e, f, g, h)
elif d < b and c <= a:
  e = c + dy
  f = d - dx
  g = e + dx
  h = f + dy
  print(e, f, g, h)
else:
  e = c + dx
  f = d + dy
  g = e - dx
  h = f + dy
  print(e, f, g, h)

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

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

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):
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())
dx = x2 - x1
dy = y2 - y1
x3 = x2 - dy
y3 = y2 + dx
x4 = x3 - dx
y4 = y3 - dy
print(str(x3)+' '+str(y3)+' '+str(x4)+' '+str(y4))

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


x1, y1, x2, y2 =z[0],z[1],z[2],z[3] 
dx = x2-x1
dy = y2-y1
z1 = [0]*4
z1[0] = x2-dy
z1[1] = y2+dx
z1[2] = z1[0] - dx
z1[3] = z1[1] - dy

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

Solution (Python):
x0,y0,x1,y1=map(int,input().split())



dx=x1-x0
dy=y1-y0

x2=x1-dy
y2=y1+dx

x3=x2-dx
y3=y2-dy

print(x2,y2,x3,y3)

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

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

x = c-a
y = d-b

e = c-y
f = d+x
g = e-x
h = f-y
ans =[str(e), str(f), str(g), str(h)]

print(" ".join(ans))

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

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

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 = x3 - (x2 - x1)
y4 = y3 - (y2 - y1)
print("{} {} {} {}".format(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):
li=list(map(int,input().split()))
X=li[2]-li[0]
Y=li[3]-li[1]
L = [li[2]-Y,li[3]+X,li[0]-Y,li[1]+X]
print(' '.join(map(str, L)))

Solution (Python):
x1, y1, x2, y2 = map(int,input().split())
vec_x = y1 - y2
vex_y = x2 - x1
ans = list(map(str, [x2+vec_x, y2+vex_y, x1+vec_x, y1+vex_y]))
print(" ".join(ans))

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

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

w = x2 - x1
h = y2 - y1

x3 = x2 - h
y3 = y2 + w

x4 = x1 - h
y4 = y1 + w

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

Solution (Python):
x1, y1, x2, y2 = map(int,input().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())
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())
v=[x2-x1,y2-y1]
x3,y3=x2-v[1],y2+v[0]
x4,y4=x3-v[0],y3-v[1]
print(x3,y3,x4,y4)

Solution (Python):



x1,y1,x2,y2 = list(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):
ax, ay, bx, by = map(int, input().split())
c = bx - ax
d = by - ay
ex = bx - d
ey = by + c
fx = ax - d
fy = ay + c
print(str(ex) + " " + str(ey) + " " + str(fx) + " " + str(fy))

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)